Changeset 213736 in webkit


Ignore:
Timestamp:
Mar 10, 2017 4:46:44 PM (7 years ago)
Author:
commit-queue@webkit.org
Message:

Move libwebrtc backend to using tracks
​https://bugs.webkit.org/show_bug.cgi?id=169472

Patch by Youenn Fablet <​youenn@apple.com> on 2017-03-10
Reviewed by Alex Christensen.

Source/ThirdParty/libwebrtc:

  • Source/webrtc/pc/rtcstatscollector.cc: Moving from using media stream to tracks.

Source/WebCore:

Covered by current test sets.

This change allows to move away from streams and use more tracks.
This allows future better alignment with the spec and better implementation of sender/receover/transceiver.

Small refactoring to use more Ref<> in WebRTC track-based code.
Added a notifyAddedTrack to notify the backend that a track was added.
For libwebrtc, this allows calling AddTrack before making the offer.
Updated mock libwebrtc backend accordingly.

  • Modules/mediastream/MediaEndpointPeerConnection.cpp:

(WebCore::MediaEndpointPeerConnection::replaceTrack):
(WebCore::MediaEndpointPeerConnection::replaceTrackTask):

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

(WebCore::PeerConnectionBackend::notifyAddedTrack):

  • Modules/mediastream/RTCPeerConnection.cpp:

(WebCore::RTCPeerConnection::addTrack):
(WebCore::RTCPeerConnection::replaceTrack):

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

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

  • Modules/mediastream/RTCRtpSender.h:
  • Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp:

(WebCore::LibWebRTCMediaEndpoint::addTrack):
(WebCore::LibWebRTCMediaEndpoint::doCreateOffer):
(WebCore::LibWebRTCMediaEndpoint::doCreateAnswer):
(WebCore::LibWebRTCMediaEndpoint::getStats):

  • Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.h:
  • Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp:

(WebCore::LibWebRTCPeerConnectionBackend::doAddIceCandidate):
(WebCore::LibWebRTCPeerConnectionBackend::notifyAddedTrack):

  • Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.h:
  • testing/MockLibWebRTCPeerConnection.cpp:

(WebCore::MockLibWebRTCPeerConnection::AddTrack):
(WebCore::MockLibWebRTCPeerConnection::RemoveTrack):
(WebCore::MockLibWebRTCPeerConnection::CreateOffer):
(WebCore::MockLibWebRTCPeerConnection::CreateAnswer):

  • testing/MockLibWebRTCPeerConnection.h:

(WebCore::MockRtpSender::MockRtpSender):
(WebCore::MockRtpSender::ssrc):
(WebCore::MockRtpSender::media_type):
(WebCore::MockRtpSender::id):
(WebCore::MockRtpSender::stream_ids):
(WebCore::MockRtpSender::GetParameters):
(WebCore::MockRtpSender::SetParameters):
(WebCore::MockRtpSender::GetDtmfSender):

LayoutTests:

Location:
trunk
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r213735 r213736  
     12017-03-10  Youenn Fablet  <youenn@apple.com>
     2
     3        Move libwebrtc backend to using tracks
     4        https://bugs.webkit.org/show_bug.cgi?id=169472
     5
     6        Reviewed by Alex Christensen.
     7
     8        * TestExpectations:
     9
    1102017-03-10  Ryan Haddad  <ryanhaddad@apple.com>
    211

  • trunk/LayoutTests/TestExpectations

    r213723 r213736  
    716716# See webkit.org/b/168736
    717717fast/mediastream/RTCPeerConnection-addIceCandidate.html [ Failure  ]
    718 fast/mediastream/RTCPeerConnection-addTrack-reuse-sender.html [ Failure  ]
    719 fast/mediastream/RTCPeerConnection-legacy-stream-based-api.html [ Failure  ]
    720718imported/w3c/web-platform-tests/webrtc/datachannel-emptystring.html [ Failure  ]
    721719imported/w3c/web-platform-tests/webrtc/no-media-call.html [ Failure  ]

  • trunk/Source/ThirdParty/libwebrtc/ChangeLog

    r213605 r213736  
     12017-03-10  Youenn Fablet  <youenn@apple.com>
     2
     3        Move libwebrtc backend to using tracks
     4        https://bugs.webkit.org/show_bug.cgi?id=169472
     5
     6        Reviewed by Alex Christensen.
     7
     8        * Source/webrtc/pc/rtcstatscollector.cc: Moving from using media stream to tracks.
     9
    1102017-03-08  Youenn Fablet  <youenn@apple.com>
    211

  • trunk/Source/ThirdParty/libwebrtc/Source/webrtc/pc/rtcstatscollector.cc

    r213418 r213736  
    11991199  RTC_DCHECK(signaling_thread_->IsCurrent());
    12001200  std::map<MediaStreamTrackInterface*, std::string> track_to_id;
     1201#if defined(WEBRTC_WEBKIT_BUILD)
     1202  for (auto& sender : pc_->GetSenders()) {
     1203    auto track = sender->track();
     1204    if (!track)
     1205      continue;
     1206    track_to_id[track.get()] = track->id();
     1207  }
     1208  for (auto& receiver : pc_->GetReceivers()) {
     1209    auto track = receiver->track();
     1210    if (!track)
     1211      continue;
     1212    track_to_id[track.get()] = track->id();
     1213  }
     1214#else
    12011215  StreamCollectionInterface* local_and_remote_streams[] =
    12021216      { pc_->local_streams().get(), pc_->remote_streams().get() };
    … …  
    12161230    }
    12171231  }
     1232#endif
    12181233  return track_to_id;
    12191234}

  • trunk/Source/WebCore/ChangeLog

    r213733 r213736  
     12017-03-10  Youenn Fablet  <youenn@apple.com>
     2
     3        Move libwebrtc backend to using tracks
     4        https://bugs.webkit.org/show_bug.cgi?id=169472
     5
     6        Reviewed by Alex Christensen.
     7
     8        Covered by current test sets.
     9
     10        This change allows to move away from streams and use more tracks.
     11        This allows future better alignment with the spec and better implementation of sender/receover/transceiver.
     12
     13        Small refactoring to use more Ref<> in WebRTC track-based code.
     14        Added a notifyAddedTrack to notify the backend that a track was added.
     15        For libwebrtc, this allows calling AddTrack before making the offer.
     16        Updated mock libwebrtc backend accordingly.
     17
     18        * Modules/mediastream/MediaEndpointPeerConnection.cpp:
     19        (WebCore::MediaEndpointPeerConnection::replaceTrack):
     20        (WebCore::MediaEndpointPeerConnection::replaceTrackTask):
     21        * Modules/mediastream/MediaEndpointPeerConnection.h:
     22        * Modules/mediastream/PeerConnectionBackend.h:
     23        (WebCore::PeerConnectionBackend::notifyAddedTrack):
     24        * Modules/mediastream/RTCPeerConnection.cpp:
     25        (WebCore::RTCPeerConnection::addTrack):
     26        (WebCore::RTCPeerConnection::replaceTrack):
     27        * Modules/mediastream/RTCPeerConnection.h:
     28        * Modules/mediastream/RTCRtpSender.cpp:
     29        (WebCore::RTCRtpSender::create):
     30        (WebCore::RTCRtpSender::RTCRtpSender):
     31        (WebCore::RTCRtpSender::setTrack):
     32        * Modules/mediastream/RTCRtpSender.h:
     33        * Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp:
     34        (WebCore::LibWebRTCMediaEndpoint::addTrack):
     35        (WebCore::LibWebRTCMediaEndpoint::doCreateOffer):
     36        (WebCore::LibWebRTCMediaEndpoint::doCreateAnswer):
     37        (WebCore::LibWebRTCMediaEndpoint::getStats):
     38        * Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.h:
     39        * Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp:
     40        (WebCore::LibWebRTCPeerConnectionBackend::doAddIceCandidate):
     41        (WebCore::LibWebRTCPeerConnectionBackend::notifyAddedTrack):
     42        * Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.h:
     43        * testing/MockLibWebRTCPeerConnection.cpp:
     44        (WebCore::MockLibWebRTCPeerConnection::AddTrack):
     45        (WebCore::MockLibWebRTCPeerConnection::RemoveTrack):
     46        (WebCore::MockLibWebRTCPeerConnection::CreateOffer):
     47        (WebCore::MockLibWebRTCPeerConnection::CreateAnswer):
     48        * testing/MockLibWebRTCPeerConnection.h:
     49        (WebCore::MockRtpSender::MockRtpSender):
     50        (WebCore::MockRtpSender::ssrc):
     51        (WebCore::MockRtpSender::media_type):
     52        (WebCore::MockRtpSender::id):
     53        (WebCore::MockRtpSender::stream_ids):
     54        (WebCore::MockRtpSender::GetParameters):
     55        (WebCore::MockRtpSender::SetParameters):
     56        (WebCore::MockRtpSender::GetDtmfSender):
     57
    1582017-03-10  Zalan Bujtas  <zalan@apple.com>
    259

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

    r212338 r213736  
    694694}
    695695
    696 void MediaEndpointPeerConnection::replaceTrack(RTCRtpSender& sender, RefPtr<MediaStreamTrack>&& withTrack, DOMPromise<void>&& promise)
     696void MediaEndpointPeerConnection::replaceTrack(RTCRtpSender& sender, Ref<MediaStreamTrack>&& withTrack, DOMPromise<void>&& promise)
    697697{
    698698    RTCRtpTransceiver* transceiver = matchTransceiver(m_peerConnection.getTransceivers(), [&sender] (RTCRtpTransceiver& current) {
    … …  
    714714}
    715715
    716 void MediaEndpointPeerConnection::replaceTrackTask(RTCRtpSender& sender, const String& mid, RefPtr<MediaStreamTrack>&& withTrack, DOMPromise<void>& promise)
     716void MediaEndpointPeerConnection::replaceTrackTask(RTCRtpSender& sender, const String& mid, Ref<MediaStreamTrack>&& withTrack, DOMPromise<void>& promise)
    717717{
    718718    if (m_peerConnection.internalSignalingState() == SignalingState::Closed)

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

    r212338 r213736  
    6363
    6464    Ref<RTCRtpReceiver> createReceiver(const String& transceiverMid, const String& trackKind, const String& trackId) final;
    65     void replaceTrack(RTCRtpSender&, RefPtr<MediaStreamTrack>&&, DOMPromise<void>&&) final;
     65    void replaceTrack(RTCRtpSender&, Ref<MediaStreamTrack>&&, DOMPromise<void>&&) final;
    6666
    6767    void emulatePlatformEvent(const String& action) final;
    … …  
    8585    void addIceCandidateTask(RTCIceCandidate&);
    8686
    87     void replaceTrackTask(RTCRtpSender&, const String& mid, RefPtr<MediaStreamTrack>&&, DOMPromise<void>&);
     87    void replaceTrackTask(RTCRtpSender&, const String& mid, Ref<MediaStreamTrack>&&, DOMPromise<void>&);
    8888
    8989    bool localDescriptionTypeValidForState(RTCSessionDescription::SdpType) const;

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

    r212745 r213736  
    9494
    9595    virtual Ref<RTCRtpReceiver> createReceiver(const String& transceiverMid, const String& trackKind, const String& trackId) = 0;
    96     virtual void replaceTrack(RTCRtpSender&, RefPtr<MediaStreamTrack>&&, DOMPromise<void>&&) = 0;
     96    virtual void replaceTrack(RTCRtpSender&, Ref<MediaStreamTrack>&&, DOMPromise<void>&&) = 0;
     97    virtual void notifyAddedTrack(RTCRtpSender&) { }
    9798
    9899    void markAsNeedingNegotiation();

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

    r212745 r213736  
    124124            transceiver->enableSendingDirection();
    125125            sender = &existingSender;
     126           
    126127            break;
    127128        }
    … …  
    147148    m_backend->markAsNeedingNegotiation();
    148149
     150    m_backend->notifyAddedTrack(*sender);
    149151    return Ref<RTCRtpSender> { *sender };
    150152}
    … …  
    511513}
    512514
    513 void RTCPeerConnection::replaceTrack(RTCRtpSender& sender, RefPtr<MediaStreamTrack>&& withTrack, DOMPromise<void>&& promise)
     515void RTCPeerConnection::replaceTrack(RTCRtpSender& sender, Ref<MediaStreamTrack>&& withTrack, DOMPromise<void>&& promise)
    514516{
    515517    m_backend->replaceTrack(sender, WTFMove(withTrack), WTFMove(promise));

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

    r212745 r213736  
    160160
    161161    // RTCRtpSenderClient
    162     void replaceTrack(RTCRtpSender&, RefPtr<MediaStreamTrack>&&, DOMPromise<void>&&) final;
     162    void replaceTrack(RTCRtpSender&, Ref<MediaStreamTrack>&&, DOMPromise<void>&&) final;
    163163
    164164    PeerConnectionStates::SignalingState m_signalingState { PeerConnectionStates::SignalingState::Stable };

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

    r209390 r213736  
    4040Ref<RTCRtpSender> RTCRtpSender::create(Ref<MediaStreamTrack>&& track, Vector<String>&& mediaStreamIds, RTCRtpSenderClient& client)
    4141{
    42     const String& trackKind = track->kind();
    43     return adoptRef(*new RTCRtpSender(WTFMove(track), trackKind, WTFMove(mediaStreamIds), client));
     42    auto sender = adoptRef(*new RTCRtpSender(track->kind(), WTFMove(mediaStreamIds), client));
     43    sender->setTrack(WTFMove(track));
     44    return sender;
    4445}
    4546
    4647Ref<RTCRtpSender> RTCRtpSender::create(const String& trackKind, Vector<String>&& mediaStreamIds, RTCRtpSenderClient& client)
    4748{
    48     return adoptRef(*new RTCRtpSender(nullptr, trackKind, WTFMove(mediaStreamIds), client));
     49    return adoptRef(*new RTCRtpSender(trackKind, WTFMove(mediaStreamIds), client));
    4950}
    5051
    51 RTCRtpSender::RTCRtpSender(RefPtr<MediaStreamTrack>&& track, const String& trackKind, Vector<String>&& mediaStreamIds, RTCRtpSenderClient& client)
     52RTCRtpSender::RTCRtpSender(const String& trackKind, Vector<String>&& mediaStreamIds, RTCRtpSenderClient& client)
    5253    : RTCRtpSenderReceiverBase()
    5354    , m_trackKind(trackKind)
    … …  
    5556    , m_client(&client)
    5657{
    57     setTrack(WTFMove(track));
    5858}
    5959
    60 void RTCRtpSender::setTrack(RefPtr<MediaStreamTrack>&& track)
     60void RTCRtpSender::setTrack(Ref<MediaStreamTrack>&& track)
    6161{
    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 
     62    ASSERT(!isStopped());
     63    ASSERT(!m_track);
     64    m_trackId = track->id();
    6765    m_track = WTFMove(track);
    6866}

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

    r209390 r213736  
    4040class RTCRtpSenderClient {
    4141public:
    42     virtual void replaceTrack(RTCRtpSender&, RefPtr<MediaStreamTrack>&&, DOMPromise<void>&&) = 0;
     42    virtual void replaceTrack(RTCRtpSender&, Ref<MediaStreamTrack>&&, DOMPromise<void>&&) = 0;
    4343
    4444    virtual ~RTCRtpSenderClient() { }
    … …  
    5858    bool isStopped() const { return !m_client; }
    5959    void stop() { m_client = nullptr; }
    60     void setTrack(RefPtr<MediaStreamTrack>&&);
     60    void setTrack(Ref<MediaStreamTrack>&&);
    6161
    6262    ExceptionOr<void> replaceTrack(Ref<MediaStreamTrack>&&, DOMPromise<void>&&);
    6363
    6464private:
    65     RTCRtpSender(RefPtr<MediaStreamTrack>&&, const String& trackKind, Vector<String>&& mediaStreamIds, RTCRtpSenderClient&);
     65    RTCRtpSender(const String& trackKind, Vector<String>&& mediaStreamIds, RTCRtpSenderClient&);
    6666
    6767    String m_trackId;

  • trunk/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp

    r213520 r213736  
    159159}
    160160
    161 static inline std::string streamId(RTCPeerConnection& connection)
    162 {
    163     auto& senders = connection.getSenders();
    164     if (senders.size()) {
    165         for (RTCRtpSender& sender : senders) {
    166             auto* track = sender.track();
    167             if (track) {
    168                 ASSERT(sender.mediaStreamIds().size() == 1);
    169                 return std::string(sender.mediaStreamIds().first().utf8().data());
    170             }
    171         }
    172     }
    173     return "av_label";
     161void LibWebRTCMediaEndpoint::addTrack(MediaStreamTrack& track, const Vector<String>& mediaStreamIds)
     162{
     163    if (!LibWebRTCProvider::factory())
     164        return;
     165
     166    std::vector<webrtc::MediaStreamInterface*> mediaStreams;
     167    rtc::scoped_refptr<webrtc::MediaStreamInterface> mediaStream = nullptr;
     168    if (mediaStreamIds.size()) {
     169        // libwebrtc is only using the first one if any.
     170        mediaStream = LibWebRTCProvider::factory()->CreateLocalMediaStream(mediaStreamIds[0].utf8().data());
     171        mediaStreams.push_back(mediaStream.get());
     172    }
     173   
     174    auto& source = track.source();
     175    ASSERT(source.type() != RealtimeMediaSource::None);
     176
     177    if (source.type() == RealtimeMediaSource::Audio) {
     178        auto trackSource = RealtimeOutgoingAudioSource::create(source);
     179        auto audioTrack = LibWebRTCProvider::factory()->CreateAudioTrack(track.id().utf8().data(), trackSource.ptr());
     180        trackSource->setTrack(rtc::scoped_refptr<webrtc::AudioTrackInterface>(audioTrack));
     181        m_peerConnectionBackend.addAudioSource(WTFMove(trackSource));
     182        m_backend->AddTrack(audioTrack.get(), WTFMove(mediaStreams));
     183    } else {
     184        auto videoSource = RealtimeOutgoingVideoSource::create(source);
     185        auto videoTrack = LibWebRTCProvider::factory()->CreateVideoTrack(track.id().utf8().data(), videoSource.ptr());
     186        m_peerConnectionBackend.addVideoSource(WTFMove(videoSource));
     187        m_backend->AddTrack(videoTrack.get(), WTFMove(mediaStreams));
     188    }
    174189}
    175190
    … …  
    182197       
    183198    m_isInitiator = true;
    184     auto& senders = m_peerConnectionBackend.connection().getSenders();
    185     if (senders.size()) {
    186         // FIXME: We only support one stream for the moment.
    187         auto stream = LibWebRTCProvider::factory()->CreateLocalMediaStream(streamId(m_peerConnectionBackend.connection()));
    188         for (RTCRtpSender& sender : senders) {
    189             auto* track = sender.track();
    190             if (track) {
    191                 ASSERT(sender.mediaStreamIds().size() == 1);
    192                 auto& source = track->source();
    193                 if (source.type() == RealtimeMediaSource::Audio) {
    194                     auto trackSource = RealtimeOutgoingAudioSource::create(source);
    195                     auto rtcTrack = LibWebRTCProvider::factory()->CreateAudioTrack(track->id().utf8().data(), trackSource.ptr());
    196                     trackSource->setTrack(rtc::scoped_refptr<webrtc::AudioTrackInterface>(rtcTrack));
    197                     m_peerConnectionBackend.addAudioSource(WTFMove(trackSource));
    198                     stream->AddTrack(WTFMove(rtcTrack));
    199                 } else {
    200                     auto videoSource = RealtimeOutgoingVideoSource::create(source);
    201                     auto videoTrack = LibWebRTCProvider::factory()->CreateVideoTrack(track->id().utf8().data(), videoSource.ptr());
    202                     m_peerConnectionBackend.addVideoSource(WTFMove(videoSource));
    203                     stream->AddTrack(WTFMove(videoTrack));
    204                 }
    205             }
    206         }
    207         m_backend->AddStream(stream);
    208     }
    209199    m_backend->CreateOffer(&m_createSessionDescriptionObserver, nullptr);
    210200}
    … …  
    218208
    219209    m_isInitiator = false;
    220 
    221     auto& senders = m_peerConnectionBackend.connection().getSenders();
    222     if (senders.size()) {
    223         // FIXME: We only support one stream for the moment.
    224         auto stream = LibWebRTCProvider::factory()->CreateLocalMediaStream(streamId(m_peerConnectionBackend.connection()));
    225         for (RTCRtpSender& sender : senders) {
    226             auto* track = sender.track();
    227             if (track) {
    228                 ASSERT(sender.mediaStreamIds().size() == 1);
    229                 auto& source = track->source();
    230                 if (source.type() == RealtimeMediaSource::Audio) {
    231                     auto trackSource = RealtimeOutgoingAudioSource::create(source);
    232                     auto rtcTrack = LibWebRTCProvider::factory()->CreateAudioTrack(track->id().utf8().data(), trackSource.ptr());
    233                     trackSource->setTrack(rtc::scoped_refptr<webrtc::AudioTrackInterface>(rtcTrack));
    234                     m_peerConnectionBackend.addAudioSource(WTFMove(trackSource));
    235                     stream->AddTrack(WTFMove(rtcTrack));
    236                 } else {
    237                     auto videoSource = RealtimeOutgoingVideoSource::create(source);
    238                     auto videoTrack = LibWebRTCProvider::factory()->CreateVideoTrack(track->id().utf8().data(), videoSource.ptr());
    239                     m_peerConnectionBackend.addVideoSource(WTFMove(videoSource));
    240                     stream->AddTrack(WTFMove(videoTrack));
    241                 }
    242             }
    243         }
    244         m_backend->AddStream(stream);
    245     }
    246210    m_backend->CreateAnswer(&m_createSessionDescriptionObserver, nullptr);
    247211}
    … …  
    249213void LibWebRTCMediaEndpoint::getStats(MediaStreamTrack* track, const DeferredPromise& promise)
    250214{
     215    UNUSED_PARAM(track);
     216    UNUSED_PARAM(promise);
    251217    m_backend->GetStats(StatsCollector::create(*this, promise, track).get());
    252218}

  • trunk/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.h

    r213520 r213736  
    7979    RefPtr<RTCSessionDescription> pendingLocalDescription() const;
    8080    RefPtr<RTCSessionDescription> pendingRemoteDescription() const;
     81
     82    void addTrack(MediaStreamTrack&, const Vector<String>&);
    8183
    8284private:

  • trunk/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp

    r213613 r213736  
    170170void LibWebRTCPeerConnectionBackend::doAddIceCandidate(RTCIceCandidate& candidate)
    171171{
    172     if (!m_isRemoteDescriptionSet) {
    173         addIceCandidateFailed(Exception { INVALID_STATE_ERR, "No remote description set" });
    174         return;
    175     }
    176 
    177172    webrtc::SdpParseError error;
    178173    int sdpMLineIndex = candidate.sdpMLineIndex() ? candidate.sdpMLineIndex().value() : 0;
    … …  
    251246}
    252247
     248void LibWebRTCPeerConnectionBackend::notifyAddedTrack(RTCRtpSender& sender)
     249{
     250    ASSERT(sender.track());
     251    m_endpoint->addTrack(*sender.track(), sender.mediaStreamIds());
     252}
     253
    253254} // namespace WebCore
    254255

  • trunk/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.h

    r213520 r213736  
    6868    RefPtr<RTCSessionDescription> pendingRemoteDescription() const final;
    6969
     70    void notifyAddedTrack(RTCRtpSender&) final;
    7071    // FIXME: API to implement for real
    7172    Vector<RefPtr<MediaStream>> getRemoteStreams() const final { return { }; }
    72     void replaceTrack(RTCRtpSender&, RefPtr<MediaStreamTrack>&&, DOMPromise<void>&&) final { }
     73    void replaceTrack(RTCRtpSender&, Ref<MediaStreamTrack>&&, DOMPromise<void>&&) final { }
    7374
    7475    void emulatePlatformEvent(const String&) final { }

  • trunk/Source/WebCore/testing/MockLibWebRTCPeerConnection.cpp

    r213190 r213736  
    227227}
    228228
    229 bool MockLibWebRTCPeerConnection::AddStream(webrtc::MediaStreamInterface* stream)
    230 {
    231     m_stream = stream;
     229rtc::scoped_refptr<webrtc::RtpSenderInterface> MockLibWebRTCPeerConnection::AddTrack(webrtc::MediaStreamTrackInterface* track, std::vector<webrtc::MediaStreamInterface*> streams)
     230{
    232231    LibWebRTCProvider::callOnWebRTCSignalingThread([observer = &m_observer] {
    233232        observer->OnRenegotiationNeeded();
    234233    });
    235     return true;
    236 }
    237 
    238 void MockLibWebRTCPeerConnection::RemoveStream(webrtc::MediaStreamInterface*)
     234
     235    if (streams.size())
     236        m_streamLabel = streams.front()->label();
     237
     238    m_senders.append(new rtc::RefCountedObject<MockRtpSender>(rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>(track)));
     239    return m_senders.last().get();
     240}
     241
     242bool MockLibWebRTCPeerConnection::RemoveTrack(webrtc::RtpSenderInterface* sender)
    239243{
    240244    LibWebRTCProvider::callOnWebRTCSignalingThread([observer = &m_observer] {
    241245        observer->OnRenegotiationNeeded();
    242246    });
    243     m_stream = nullptr;
     247    bool isRemoved = false;
     248    return m_senders.removeFirstMatching([&](auto& item) {
     249        if (item.get() != sender)
     250            return false;
     251        isRemoved = true;
     252        return true;
     253    });
    244254}
    245255
    … …  
    253263            "s=-\r\n"
    254264            "t=0 0\r\n";
    255         if (m_stream) {
     265        if (m_senders.size()) {
    256266            unsigned partCounter = 1;
    257             sdp << "a=msid-semantic:WMS " << m_stream->label() << "\r\n";
    258             for (auto& audioTrack : m_stream->GetAudioTracks()) {
     267            sdp << "a=msid-semantic:WMS " << m_streamLabel << "\r\n";
     268            for (auto& sender : m_senders) {
     269                auto track = sender->track();
     270                if (track->kind() != "audio")
     271                    continue;
    259272                sdp <<
    260273                    "m=audio 9 UDP/TLS/RTP/SAVPF 111 8 0\r\n"
    … …  
    267280                    "a=rtpmap:0 PCMU/8000\r\n"
    268281                    "a=ssrc:3409173717 cname:/chKzCS9K6KOgL0n\r\n"
    269                     "a=msid:" << m_stream->label() << " " << audioTrack->id() << "\r\n"
     282                    "a=msid:" << m_streamLabel << " " << track->id() << "\r\n"
    270283                    "a=ice-ufrag:e/B1\r\n"
    271284                    "a=ice-pwd:Yotk3Im3mnyi+1Q38p51MDub\r\n"
    … …  
    273286                    "a=setup:actpass\r\n";
    274287            }
    275             for (auto& videoTrack : m_stream->GetVideoTracks()) {
     288            for (auto& sender : m_senders) {
     289                auto track = sender->track();
     290                if (track->kind() != "video")
     291                    continue;
    276292                sdp <<
    277293                    "m=video 9 UDP/TLS/RTP/SAVPF 103 100 120\r\n"
    … …  
    291307                    "a=rtcp-fb:100 ccm fir\r\n"
    292308                    "a=ssrc:3409173718 cname:/chKzCS9K6KOgL0n\r\n"
    293                     "a=msid:" << m_stream->label() << " " << videoTrack->id() << "\r\n"
     309                    "a=msid:" << m_streamLabel << " " << track->id() << "\r\n"
    294310                    "a=ice-ufrag:e/B1\r\n"
    295311                    "a=ice-pwd:Yotk3Im3mnyi+1Q38p51MDub\r\n"
    … …  
    312328            "s=-\r\n"
    313329            "t=0 0\r\n";
    314         if (m_stream) {
    315             for (auto& audioTrack : m_stream->GetAudioTracks()) {
    316                 ASSERT_UNUSED(audioTrack, !!audioTrack);
     330        if (m_senders.size()) {
     331            for (auto& sender : m_senders) {
     332                auto track = sender->track();
     333                if (track->kind() != "audio")
     334                    continue;
    317335                sdp <<
    318336                    "m=audio 9 UDP/TLS/RTP/SAVPF 111 8 0\r\n"
    … …  
    330348                    "a=setup:active\r\n";
    331349            }
    332             for (auto& videoTrack : m_stream->GetVideoTracks()) {
    333                 ASSERT_UNUSED(videoTrack, !!videoTrack);
     350            for (auto& sender : m_senders) {
     351                auto track = sender->track();
     352                if (track->kind() != "video")
     353                    continue;
    334354                sdp <<
    335355                    "m=video 9 UDP/TLS/RTP/SAVPF 103 100 120\r\n"

  • trunk/Source/WebCore/testing/MockLibWebRTCPeerConnection.h

    r213418 r213736  
    3535
    3636class LibWebRTCProvider;
     37class MockRtpSender;
    3738
    3839void useMockRTCPeerConnectionFactory(LibWebRTCProvider*, const String&);
    … …  
    5960    void Close() override { }
    6061
     62    bool AddStream(webrtc::MediaStreamInterface*) final { return false; }
     63    void RemoveStream(webrtc::MediaStreamInterface*) final { }
     64
    6165protected:
    6266    void SetRemoteDescription(webrtc::SetSessionDescriptionObserver*, webrtc::SessionDescriptionInterface*) final;
    6367    void CreateAnswer(webrtc::CreateSessionDescriptionObserver*, const webrtc::MediaConstraintsInterface*) final;
    6468    rtc::scoped_refptr<webrtc::DataChannelInterface> CreateDataChannel(const std::string&, const webrtc::DataChannelInit*) final;
    65     bool AddStream(webrtc::MediaStreamInterface*) final;
    66     void RemoveStream(webrtc::MediaStreamInterface*) final;
     69    rtc::scoped_refptr<webrtc::RtpSenderInterface> AddTrack(webrtc::MediaStreamTrackInterface*, std::vector<webrtc::MediaStreamInterface*> streams) final;
     70    bool RemoveTrack(webrtc::RtpSenderInterface*) final;
    6771
    6872    void SetLocalDescription(webrtc::SetSessionDescriptionObserver*, webrtc::SessionDescriptionInterface*) override;
    … …  
    7478    webrtc::PeerConnectionObserver& m_observer;
    7579    unsigned m_counter { 0 };
    76     rtc::scoped_refptr<webrtc::MediaStreamInterface> m_stream;
     80    Vector<rtc::scoped_refptr<MockRtpSender>> m_senders;
    7781    bool m_isInitiator { true };
    7882    bool m_isReceivingAudio { false };
    7983    bool m_isReceivingVideo { false };
     84    std::string m_streamLabel;
    8085};
    8186
    … …  
    200205};
    201206
     207class MockRtpSender : public webrtc::RtpSenderInterface {
     208public:
     209    MockRtpSender(rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>&& track) : m_track(WTFMove(track)) { }
     210
     211    bool SetTrack(webrtc::MediaStreamTrackInterface*) final { return false; }
     212    rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> track() const final { return m_track; }
     213   
     214    uint32_t ssrc() const { return 0; }
     215    cricket::MediaType media_type() const { return cricket::MEDIA_TYPE_VIDEO; }
     216    std::string id() const { return ""; }
     217    std::vector<std::string> stream_ids() const { return { }; }
     218    webrtc::RtpParameters GetParameters() const { return { }; }
     219    bool SetParameters(const webrtc::RtpParameters&) { return false; }
     220    rtc::scoped_refptr<webrtc::DtmfSenderInterface> GetDtmfSender() const { return nullptr; }
     221
     222private:
     223    rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> m_track;
     224};
     225   
    202226class MockLibWebRTCPeerConnectionFactory : public webrtc::PeerConnectionFactoryInterface {
    203227public:
Note: See TracChangeset for help on using the changeset viewer.