Changeset 211837 in webkit


Ignore:
Timestamp:
Feb 7, 2017 1:56:42 PM (7 years ago)
Author:
commit-queue@webkit.org
Message:

[WebRTC] LibWebRTCEndpoint should not own objects that should be destroyed on the main thread
https://bugs.webkit.org/show_bug.cgi?id=167816

Patch by Youenn Fablet <youennf@gmail.com> on 2017-02-07
Reviewed by Alex Christensen.

Source/WebCore:

Tests: webrtc/libwebrtc/release-while-creating-offer.html

webrtc/libwebrtc/release-while-getting-stats.html
webrtc/libwebrtc/release-while-setting-local-description.html

Moving AV sources, stats promises, ICE candidates from LibWebRTCEndpoint to LibWebRTCPeerConnectionBackend.
This allows ensuring these are destroyed in the main thread.

  • Modules/mediastream/MediaEndpointPeerConnection.cpp:

(WebCore::MediaEndpointPeerConnection::getStats):

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

(WebCore::RTCPeerConnection::getStats):

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

(WebCore::LibWebRTCMediaEndpoint::doCreateOffer):
(WebCore::LibWebRTCMediaEndpoint::doCreateAnswer):
(WebCore::LibWebRTCMediaEndpoint::getStats):
(WebCore::LibWebRTCMediaEndpoint::StatsCollector::StatsCollector):
(WebCore::LibWebRTCMediaEndpoint::StatsCollector::OnStatsDelivered):

  • Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.h:

(WebCore::LibWebRTCMediaEndpoint::addIceCandidate):
(WebCore::LibWebRTCMediaEndpoint::isStopped):

  • Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp:

(WebCore::LibWebRTCPeerConnectionBackend::~LibWebRTCPeerConnectionBackend):
(WebCore::LibWebRTCPeerConnectionBackend::getStats):
(WebCore::LibWebRTCPeerConnectionBackend::iceCandidateSucceeded):
(WebCore::LibWebRTCPeerConnectionBackend::iceCandidateFailed):
(WebCore::LibWebRTCPeerConnectionBackend::doSetLocalDescription):
(WebCore::LibWebRTCPeerConnectionBackend::doSetRemoteDescription):
(WebCore::LibWebRTCPeerConnectionBackend::doAddIceCandidate):
(WebCore::LibWebRTCPeerConnectionBackend::addAudioSource):
(WebCore::LibWebRTCPeerConnectionBackend::addVideoSource):

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

(WebCore::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileCreatingOffer::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileCreatingOffer):
(WebCore::releaseInNetworkThread):
(WebCore::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileCreatingOffer::CreateOffer):
(WebCore::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileGettingStats::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileGettingStats):
(WebCore::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileGettingStats::GetStats):
(WebCore::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileSettingDescription::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileSettingDescription):
(WebCore::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileSettingDescription::SetLocalDescription):
(WebCore::MockLibWebRTCPeerConnectionFactory::CreatePeerConnection):

  • testing/MockLibWebRTCPeerConnection.h:

LayoutTests:

  • webrtc/libwebrtc/release-while-creating-offer.html: Added.
  • webrtc/libwebrtc/release-while-getting-stats.html: Added.
  • webrtc/libwebrtc/release-while-setting-local-description.html: Added.
Location:
trunk
Files:
4 added
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r211830 r211837  
     12017-02-07  Youenn Fablet  <youennf@gmail.com>
     2
     3        [WebRTC] LibWebRTCEndpoint should not own objects that should be destroyed on the main thread
     4        https://bugs.webkit.org/show_bug.cgi?id=167816
     5
     6        Reviewed by Alex Christensen.
     7
     8        * webrtc/libwebrtc/release-while-creating-offer.html: Added.
     9        * webrtc/libwebrtc/release-while-getting-stats.html: Added.
     10        * webrtc/libwebrtc/release-while-setting-local-description.html: Added.
     11
    1122017-02-07  Youenn Fablet  <youennf@gmail.com>
    213
  • trunk/Source/WebCore/ChangeLog

    r211836 r211837  
     12017-02-07  Youenn Fablet  <youennf@gmail.com>
     2
     3        [WebRTC] LibWebRTCEndpoint should not own objects that should be destroyed on the main thread
     4        https://bugs.webkit.org/show_bug.cgi?id=167816
     5
     6        Reviewed by Alex Christensen.
     7
     8        Tests: webrtc/libwebrtc/release-while-creating-offer.html
     9               webrtc/libwebrtc/release-while-getting-stats.html
     10               webrtc/libwebrtc/release-while-setting-local-description.html
     11
     12        Moving AV sources, stats promises, ICE candidates from LibWebRTCEndpoint to LibWebRTCPeerConnectionBackend.
     13        This allows ensuring these are destroyed in the main thread.
     14
     15        * Modules/mediastream/MediaEndpointPeerConnection.cpp:
     16        (WebCore::MediaEndpointPeerConnection::getStats):
     17        * Modules/mediastream/MediaEndpointPeerConnection.h:
     18        * Modules/mediastream/PeerConnectionBackend.h:
     19        * Modules/mediastream/RTCPeerConnection.cpp:
     20        (WebCore::RTCPeerConnection::getStats):
     21        * Modules/mediastream/RTCPeerConnection.h:
     22        * Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp:
     23        (WebCore::LibWebRTCMediaEndpoint::doCreateOffer):
     24        (WebCore::LibWebRTCMediaEndpoint::doCreateAnswer):
     25        (WebCore::LibWebRTCMediaEndpoint::getStats):
     26        (WebCore::LibWebRTCMediaEndpoint::StatsCollector::StatsCollector):
     27        (WebCore::LibWebRTCMediaEndpoint::StatsCollector::OnStatsDelivered):
     28        * Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.h:
     29        (WebCore::LibWebRTCMediaEndpoint::addIceCandidate):
     30        (WebCore::LibWebRTCMediaEndpoint::isStopped):
     31        * Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp:
     32        (WebCore::LibWebRTCPeerConnectionBackend::~LibWebRTCPeerConnectionBackend):
     33        (WebCore::LibWebRTCPeerConnectionBackend::getStats):
     34        (WebCore::LibWebRTCPeerConnectionBackend::iceCandidateSucceeded):
     35        (WebCore::LibWebRTCPeerConnectionBackend::iceCandidateFailed):
     36        (WebCore::LibWebRTCPeerConnectionBackend::doSetLocalDescription):
     37        (WebCore::LibWebRTCPeerConnectionBackend::doSetRemoteDescription):
     38        (WebCore::LibWebRTCPeerConnectionBackend::doAddIceCandidate):
     39        (WebCore::LibWebRTCPeerConnectionBackend::addAudioSource):
     40        (WebCore::LibWebRTCPeerConnectionBackend::addVideoSource):
     41        * Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.h:
     42        * testing/MockLibWebRTCPeerConnection.cpp:
     43        (WebCore::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileCreatingOffer::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileCreatingOffer):
     44        (WebCore::releaseInNetworkThread):
     45        (WebCore::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileCreatingOffer::CreateOffer):
     46        (WebCore::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileGettingStats::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileGettingStats):
     47        (WebCore::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileGettingStats::GetStats):
     48        (WebCore::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileSettingDescription::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileSettingDescription):
     49        (WebCore::MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileSettingDescription::SetLocalDescription):
     50        (WebCore::MockLibWebRTCPeerConnectionFactory::CreatePeerConnection):
     51        * testing/MockLibWebRTCPeerConnection.h:
     52
    1532017-02-07  Myles C. Maxfield  <mmaxfield@apple.com>
    254
  • trunk/Source/WebCore/Modules/mediastream/MediaEndpointPeerConnection.cpp

    r211286 r211837  
    667667}
    668668
    669 void MediaEndpointPeerConnection::getStats(MediaStreamTrack*, PeerConnection::StatsPromise&& promise)
     669void MediaEndpointPeerConnection::getStats(MediaStreamTrack*, Ref<DeferredPromise>&& promise)
    670670{
    671671    notImplemented();
    672672
    673     promise.reject(NOT_SUPPORTED_ERR);
     673    promise->reject(NOT_SUPPORTED_ERR);
    674674}
    675675
  • trunk/Source/WebCore/Modules/mediastream/MediaEndpointPeerConnection.h

    r209695 r211837  
    5858    void setConfiguration(MediaEndpointConfiguration&&) final;
    5959
    60     void getStats(MediaStreamTrack*, PeerConnection::StatsPromise&&) final;
     60    void getStats(MediaStreamTrack*, Ref<DeferredPromise>&&) final;
    6161
    6262    Vector<RefPtr<MediaStream>> getRemoteStreams() const final;
  • trunk/Source/WebCore/Modules/mediastream/PeerConnectionBackend.h

    r209695 r211837  
    8989    virtual void setConfiguration(MediaEndpointConfiguration&&) = 0;
    9090
    91     virtual void getStats(MediaStreamTrack*, PeerConnection::StatsPromise&&) = 0;
     91    virtual void getStats(MediaStreamTrack*, Ref<DeferredPromise>&&) = 0;
    9292
    9393    virtual Vector<RefPtr<MediaStream>> getRemoteStreams() const = 0;
  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp

    r211404 r211837  
    383383}
    384384
    385 void RTCPeerConnection::getStats(MediaStreamTrack* selector, PeerConnection::StatsPromise&& promise)
     385void RTCPeerConnection::getStats(MediaStreamTrack* selector, Ref<DeferredPromise>&& promise)
    386386{
    387387    m_backend->getStats(selector, WTFMove(promise));
  • trunk/Source/WebCore/Modules/mediastream/RTCPeerConnection.h

    r211404 r211837  
    107107    ExceptionOr<void> setConfiguration(RTCConfiguration&&);
    108108
    109     void getStats(MediaStreamTrack*, PeerConnection::StatsPromise&&);
     109    void getStats(MediaStreamTrack*, Ref<DeferredPromise>&&);
    110110
    111111    ExceptionOr<Ref<RTCDataChannel>> createDataChannel(ScriptExecutionContext&, String&&, RTCDataChannelInit&&);
  • trunk/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp

    r211371 r211837  
    103103}
    104104
    105 void LibWebRTCMediaEndpoint::addPendingIceCandidates()
    106 {
    107     while (m_pendingCandidates.size())
    108         m_backend->AddIceCandidate(m_pendingCandidates.takeLast().release());
    109 }
    110 
    111105static inline std::string streamId(RTCPeerConnection& connection)
    112106{
     
    140134                    auto rtcTrack = peerConnectionFactory().CreateAudioTrack(track->id().utf8().data(), trackSource.ptr());
    141135                    trackSource->setTrack(rtc::scoped_refptr<webrtc::AudioTrackInterface>(rtcTrack));
    142                     m_audioSources.append(WTFMove(trackSource));
     136                    m_peerConnectionBackend.addAudioSource(WTFMove(trackSource));
    143137                    stream->AddTrack(WTFMove(rtcTrack));
    144138                } else {
    145                     m_videoSources.append(RealtimeOutgoingVideoSource::create(source));
    146                     stream->AddTrack(peerConnectionFactory().CreateVideoTrack(track->id().utf8().data(), m_videoSources.last().ptr()));
     139                    auto videoSource = RealtimeOutgoingVideoSource::create(source);
     140                    auto videoTrack = peerConnectionFactory().CreateVideoTrack(track->id().utf8().data(), videoSource.ptr());
     141                    m_peerConnectionBackend.addVideoSource(WTFMove(videoSource));
     142                    stream->AddTrack(WTFMove(videoTrack));
    147143                }
    148144            }
     
    170166                    auto rtcTrack = peerConnectionFactory().CreateAudioTrack(track->id().utf8().data(), trackSource.ptr());
    171167                    trackSource->setTrack(rtc::scoped_refptr<webrtc::AudioTrackInterface>(rtcTrack));
    172                     m_audioSources.append(WTFMove(trackSource));
     168                    m_peerConnectionBackend.addAudioSource(WTFMove(trackSource));
    173169                    stream->AddTrack(WTFMove(rtcTrack));
    174170                } else {
    175                     m_videoSources.append(RealtimeOutgoingVideoSource::create(source));
    176                     stream->AddTrack(peerConnectionFactory().CreateVideoTrack(track->id().utf8().data(), m_videoSources.last().ptr()));
     171                    auto videoSource = RealtimeOutgoingVideoSource::create(source);
     172                    auto videoTrack = peerConnectionFactory().CreateVideoTrack(track->id().utf8().data(), videoSource.ptr());
     173                    m_peerConnectionBackend.addVideoSource(WTFMove(videoSource));
     174                    stream->AddTrack(WTFMove(videoTrack));
    177175                }
    178176            }
     
    183181}
    184182
    185 void LibWebRTCMediaEndpoint::getStats(MediaStreamTrack* track, PeerConnection::StatsPromise&& promise)
    186 {
    187     auto collector = StatsCollector::create(*this, WTFMove(promise), track);
    188     m_backend->GetStats(collector.ptr());
    189     m_statsCollectors.append(WTFMove(collector));
    190 }
    191 
    192 LibWebRTCMediaEndpoint::StatsCollector::StatsCollector(LibWebRTCMediaEndpoint& endpoint, PeerConnection::StatsPromise&& promise, MediaStreamTrack* track)
     183void LibWebRTCMediaEndpoint::getStats(MediaStreamTrack* track, const DeferredPromise& promise)
     184{
     185    m_backend->GetStats(StatsCollector::create(*this, promise, track).get());
     186}
     187
     188LibWebRTCMediaEndpoint::StatsCollector::StatsCollector(LibWebRTCMediaEndpoint& endpoint, const DeferredPromise& promise, MediaStreamTrack* track)
    193189    : m_endpoint(endpoint)
    194     , m_promise(WTFMove(promise))
     190    , m_promise(promise)
    195191{
    196192    if (track)
     
    200196void LibWebRTCMediaEndpoint::StatsCollector::OnStatsDelivered(const rtc::scoped_refptr<const webrtc::RTCStatsReport>& report)
    201197{
    202     callOnMainThread([this, report, protector = makeRef(m_endpoint)] {
     198    callOnMainThread([protectedThis = rtc::scoped_refptr<LibWebRTCMediaEndpoint::StatsCollector>(this), report] {
     199        if (protectedThis->m_endpoint.isStopped())
     200            return;
     201
    203202        // FIXME: Fulfill promise with the report
    204203        UNUSED_PARAM(report);
    205         m_promise.reject(TypeError, ASCIILiteral("Stats API is not yet implemented"));
    206 
    207         m_endpoint.m_statsCollectors.removeFirstMatching([this](const Ref<StatsCollector>& collector) {
    208             return this == collector.ptr();
    209         });
     204
     205        protectedThis->m_endpoint.m_peerConnectionBackend.iceCandidateFailed(protectedThis->m_promise, Exception { TypeError, ASCIILiteral("Stats API is not yet implemented") });
    210206    });
    211207}
  • trunk/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.h

    r211371 r211837  
    6666    void doCreateOffer();
    6767    void doCreateAnswer();
    68     void getStats(MediaStreamTrack*, PeerConnection::StatsPromise&&);
     68    void getStats(MediaStreamTrack*, const DeferredPromise&);
    6969    std::unique_ptr<RTCDataChannelHandler> createDataChannel(const String&, const RTCDataChannelInit&);
    70 
    71     void storeIceCandidate(std::unique_ptr<webrtc::IceCandidateInterface>&& candidate) { m_pendingCandidates.append(WTFMove(candidate)); }
    72     void addPendingIceCandidates();
     70    bool addIceCandidate(webrtc::IceCandidateInterface& candidate) { return m_backend->AddIceCandidate(&candidate); }
    7371
    7472    void stop();
     73    bool isStopped() const { return !m_backend; }
    7574
    7675private:
     
    9695    void addStream(webrtc::MediaStreamInterface&);
    9796    void addDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface>&&);
    98 
    99     bool isStopped() const { return !m_backend; }
    10097
    10198    int AddRef() const { ref(); return static_cast<int>(refCount()); }
     
    144141    };
    145142
    146     class StatsCollector final : public RefCounted<StatsCollector>, public webrtc::RTCStatsCollectorCallback {
     143    class StatsCollector final : public webrtc::RTCStatsCollectorCallback {
    147144    public:
    148         static Ref<StatsCollector> create(LibWebRTCMediaEndpoint& endpoint, PeerConnection::StatsPromise&& promise, MediaStreamTrack* track) { return adoptRef(* new StatsCollector(endpoint, WTFMove(promise), track)); }
     145        static rtc::scoped_refptr<StatsCollector> create(LibWebRTCMediaEndpoint& endpoint, const DeferredPromise& promise, MediaStreamTrack* track) { return new StatsCollector(endpoint, promise, track); }
     146
     147        int AddRef() const { return m_endpoint.AddRef(); }
     148        int Release() const { return m_endpoint.Release(); }
     149
    149150    private:
    150         StatsCollector(LibWebRTCMediaEndpoint&, PeerConnection::StatsPromise&&, MediaStreamTrack*);
     151        StatsCollector(LibWebRTCMediaEndpoint&, const DeferredPromise&, MediaStreamTrack*);
    151152
    152153        void OnStatsDelivered(const rtc::scoped_refptr<const webrtc::RTCStatsReport>&) final;
    153154
    154         int AddRef() const final { ref(); return static_cast<int>(refCount()); }
    155         int Release() const final { deref(); return static_cast<int>(refCount()); }
    156 
    157155        LibWebRTCMediaEndpoint& m_endpoint;
    158         PeerConnection::StatsPromise m_promise;
     156        const DeferredPromise& m_promise;
    159157        String m_id;
    160158    };
     
    168166
    169167    bool m_isInitiator { false };
    170 
    171     Vector<std::unique_ptr<webrtc::IceCandidateInterface>> m_pendingCandidates;
    172     Vector<Ref<RealtimeOutgoingAudioSource>> m_audioSources;
    173     Vector<Ref<RealtimeOutgoingVideoSource>> m_videoSources;
    174     Vector<Ref<StatsCollector>> m_statsCollectors;
    175168};
    176169
  • trunk/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp

    r211371 r211837  
    3030#include "Document.h"
    3131#include "IceCandidate.h"
     32#include "JSRTCStatsResponse.h"
    3233#include "LibWebRTCDataChannelHandler.h"
    3334#include "LibWebRTCMediaEndpoint.h"
     
    6364}
    6465
     66LibWebRTCPeerConnectionBackend::~LibWebRTCPeerConnectionBackend()
     67{
     68}
     69
    6570static webrtc::PeerConnectionInterface::RTCConfiguration configurationFromMediaEndpointConfiguration(MediaEndpointConfiguration&& configuration)
    6671{
     
    9297}
    9398
    94 void LibWebRTCPeerConnectionBackend::getStats(MediaStreamTrack* track, PeerConnection::StatsPromise&& promise)
    95 {
    96     m_endpoint->getStats(track, WTFMove(promise));
     99void LibWebRTCPeerConnectionBackend::getStats(MediaStreamTrack* track, Ref<DeferredPromise>&& promise)
     100{
     101    if (m_endpoint->isStopped())
     102        return;
     103
     104    auto& statsPromise = promise.get();
     105    m_statsPromises.add(&statsPromise, WTFMove(promise));
     106    m_endpoint->getStats(track, statsPromise);
     107}
     108
     109void LibWebRTCPeerConnectionBackend::iceCandidateSucceeded(const DeferredPromise& promise, Ref<RTCStatsResponse>&& response)
     110{
     111    auto statsPromise = m_statsPromises.take(&promise);
     112    ASSERT(statsPromise);
     113    statsPromise.value()->resolve<IDLInterface<RTCStatsResponse>>(WTFMove(response));
     114}
     115
     116void LibWebRTCPeerConnectionBackend::iceCandidateFailed(const DeferredPromise& promise, Exception&& exception)
     117{
     118    auto statsPromise = m_statsPromises.take(&promise);
     119    ASSERT(statsPromise);
     120    statsPromise.value()->reject(WTFMove(exception));
    97121}
    98122
     
    101125    m_endpoint->doSetLocalDescription(description);
    102126    if (!m_isLocalDescriptionSet) {
    103         if (m_isRemoteDescriptionSet)
    104             m_endpoint->addPendingIceCandidates();
     127        if (m_isRemoteDescriptionSet) {
     128            while (m_pendingCandidates.size())
     129                m_endpoint->addIceCandidate(*m_pendingCandidates.takeLast().release());
     130        }
    105131        m_isLocalDescriptionSet = true;
    106132    }
     
    111137    m_endpoint->doSetRemoteDescription(description);
    112138    if (!m_isRemoteDescriptionSet) {
    113         if (m_isLocalDescriptionSet)
    114             m_endpoint->addPendingIceCandidates();
     139        if (m_isLocalDescriptionSet) {
     140            while (m_pendingCandidates.size())
     141                m_endpoint->addIceCandidate(*m_pendingCandidates.takeLast().release());
     142        }
    115143        m_isRemoteDescriptionSet = true;
    116144    }
     
    155183    // libwebrtc does not like that ice candidates are set before the description.
    156184    if (!m_isLocalDescriptionSet || !m_isRemoteDescriptionSet)
    157         m_endpoint->storeIceCandidate(WTFMove(rtcCandidate));
    158     else if (!m_endpoint->backend().AddIceCandidate(rtcCandidate.get())) {
     185        m_pendingCandidates.append(WTFMove(rtcCandidate));
     186    else if (!m_endpoint->addIceCandidate(*rtcCandidate.get())) {
    159187        ASSERT_NOT_REACHED();
    160188        addIceCandidateFailed(Exception { OperationError, ASCIILiteral("Failed to apply the received candidate") });
     
    162190    }
    163191    addIceCandidateSucceeded();
     192}
     193
     194void LibWebRTCPeerConnectionBackend::addAudioSource(Ref<RealtimeOutgoingAudioSource>&& source)
     195{
     196    m_audioSources.append(WTFMove(source));
     197}
     198
     199void LibWebRTCPeerConnectionBackend::addVideoSource(Ref<RealtimeOutgoingVideoSource>&& source)
     200{
     201    m_videoSources.append(WTFMove(source));
    164202}
    165203
  • trunk/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.h

    r211255 r211837  
    2828
    2929#include "PeerConnectionBackend.h"
     30#include <wtf/HashMap.h>
     31
     32namespace webrtc {
     33class IceCandidateInterface;
     34}
    3035
    3136namespace WebCore {
     
    3439class RTCRtpReceiver;
    3540class RTCSessionDescription;
     41class RealtimeOutgoingAudioSource;
     42class RealtimeOutgoingVideoSource;
    3643
    3744class LibWebRTCPeerConnectionBackend final : public PeerConnectionBackend {
    3845public:
    3946    explicit LibWebRTCPeerConnectionBackend(RTCPeerConnection&);
     47    ~LibWebRTCPeerConnectionBackend();
    4048
    4149private:
     
    4856    std::unique_ptr<RTCDataChannelHandler> createDataChannelHandler(const String&, const RTCDataChannelInit&) final;
    4957    void setConfiguration(MediaEndpointConfiguration&&) final;
    50     void getStats(MediaStreamTrack*, PeerConnection::StatsPromise&&) final;
     58    void getStats(MediaStreamTrack*, Ref<DeferredPromise>&&) final;
    5159    Ref<RTCRtpReceiver> createReceiver(const String& transceiverMid, const String& trackKind, const String& trackId) final;
    5260
     
    5967    RefPtr<RTCSessionDescription> currentRemoteDescription() const final { return nullptr; }
    6068    RefPtr<RTCSessionDescription> pendingRemoteDescription() const final { return nullptr; }
    61 
    6269
    6370    Vector<RefPtr<MediaStream>> getRemoteStreams() const final { return { }; }
     
    7380    friend LibWebRTCMediaEndpoint;
    7481    RTCPeerConnection& connection() { return m_peerConnection; }
     82    void addAudioSource(Ref<RealtimeOutgoingAudioSource>&&);
     83    void addVideoSource(Ref<RealtimeOutgoingVideoSource>&&);
     84
     85    void iceCandidateSucceeded(const DeferredPromise&, Ref<RTCStatsResponse>&&);
     86    void iceCandidateFailed(const DeferredPromise&, Exception&&);
    7587
    7688private:
     
    7890    bool m_isLocalDescriptionSet { false };
    7991    bool m_isRemoteDescriptionSet { false };
     92
     93    Vector<std::unique_ptr<webrtc::IceCandidateInterface>> m_pendingCandidates;
     94    Vector<Ref<RealtimeOutgoingAudioSource>> m_audioSources;
     95    Vector<Ref<RealtimeOutgoingVideoSource>> m_videoSources;
     96    HashMap<const DeferredPromise*, Ref<DeferredPromise>> m_statsPromises;
    8097};
    8198
  • trunk/Source/WebCore/testing/MockLibWebRTCPeerConnection.cpp

    r211830 r211837  
    3333#include <webrtc/api/mediastream.h>
    3434#include <wtf/Function.h>
     35#include <wtf/MainThread.h>
    3536
    3637namespace WebCore {
     
    6869    });
    6970}
    70 
    7171
    7272class MockLibWebRTCPeerConnectionForIceConnectionState : public MockLibWebRTCPeerConnection {
     
    8888    m_observer.OnIceConnectionChange(kIceConnectionNew);
    8989}
     90
     91template<typename U> static inline void releaseInNetworkThread(MockLibWebRTCPeerConnection& mock, U& observer)
     92{
     93    mock.AddRef();
     94    observer.AddRef();
     95    callOnMainThread([&mock, &observer] {
     96        callOnWebRTCNetworkThread([&mock, &observer]() {
     97            observer.Release();
     98            mock.Release();
     99        });
     100    });
     101}
     102
     103class MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileCreatingOffer : public MockLibWebRTCPeerConnection {
     104public:
     105    explicit MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileCreatingOffer(webrtc::PeerConnectionObserver& observer) : MockLibWebRTCPeerConnection(observer) { }
     106    virtual ~MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileCreatingOffer() = default;
     107
     108private:
     109    void CreateOffer(webrtc::CreateSessionDescriptionObserver* observer, const webrtc::MediaConstraintsInterface*) final { releaseInNetworkThread(*this, *observer); }
     110};
     111
     112class MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileGettingStats : public MockLibWebRTCPeerConnection {
     113public:
     114    explicit MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileGettingStats(webrtc::PeerConnectionObserver& observer) : MockLibWebRTCPeerConnection(observer) { }
     115    virtual ~MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileGettingStats() = default;
     116
     117private:
     118    bool GetStats(webrtc::StatsObserver*, webrtc::MediaStreamTrackInterface*, StatsOutputLevel) final;
     119};
     120
     121bool MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileGettingStats::GetStats(webrtc::StatsObserver* observer, webrtc::MediaStreamTrackInterface*, StatsOutputLevel)
     122{
     123    releaseInNetworkThread(*this, *observer);
     124    return true;
     125}
     126
     127class MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileSettingDescription : public MockLibWebRTCPeerConnection {
     128public:
     129    explicit MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileSettingDescription(webrtc::PeerConnectionObserver& observer) : MockLibWebRTCPeerConnection(observer) { }
     130    virtual ~MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileSettingDescription() = default;
     131
     132private:
     133    void SetLocalDescription(webrtc::SetSessionDescriptionObserver* observer, webrtc::SessionDescriptionInterface*) final { releaseInNetworkThread(*this, *observer); }
     134};
     135
    90136
    91137MockLibWebRTCPeerConnectionFactory::MockLibWebRTCPeerConnectionFactory(LibWebRTCProvider* provider, String&& testCase)
     
    116162    if (m_testCase == "ICEConnectionState")
    117163        return new rtc::RefCountedObject<MockLibWebRTCPeerConnectionForIceConnectionState>(*observer);
     164
     165    if (m_testCase == "LibWebRTCReleasingWhileCreatingOffer")
     166        return new rtc::RefCountedObject<MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileCreatingOffer>(*observer);
     167
     168    if (m_testCase == "LibWebRTCReleasingWhileGettingStats")
     169        return new rtc::RefCountedObject<MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileGettingStats>(*observer);
     170
     171    if (m_testCase == "LibWebRTCReleasingWhileSettingDescription")
     172        return new rtc::RefCountedObject<MockLibWebRTCPeerConnectionReleasedInNetworkThreadWhileSettingDescription>(*observer);
    118173
    119174    return new rtc::RefCountedObject<MockLibWebRTCPeerConnection>(*observer);
  • trunk/Source/WebCore/testing/MockLibWebRTCPeerConnection.h

    r211253 r211837  
    4646
    4747private:
    48     rtc::scoped_refptr<webrtc::StreamCollectionInterface> local_streams() { return nullptr; }
    49     rtc::scoped_refptr<webrtc::StreamCollectionInterface> remote_streams() { return nullptr; }
    50     rtc::scoped_refptr<webrtc::DtmfSenderInterface> CreateDtmfSender(webrtc::AudioTrackInterface*) { return nullptr; }
    51     bool GetStats(webrtc::StatsObserver*, webrtc::MediaStreamTrackInterface*, StatsOutputLevel) { return false; }
    52     const webrtc::SessionDescriptionInterface* local_description() const { return nullptr; }
    53     const webrtc::SessionDescriptionInterface* remote_description() const { return nullptr; }
    54     bool AddIceCandidate(const webrtc::IceCandidateInterface*) { return true; }
    55     void RegisterUMAObserver(webrtc::UMAObserver*) { }
    56     SignalingState signaling_state() { return kStable; }
    57     IceConnectionState ice_connection_state() { return kIceConnectionNew; }
    58     IceGatheringState ice_gathering_state() { return kIceGatheringNew; }
    59     void StopRtcEventLog() { }
    60     void Close() { }
    61 
    62 protected:
    63     void SetLocalDescription(webrtc::SetSessionDescriptionObserver*, webrtc::SessionDescriptionInterface*) final;
     48    rtc::scoped_refptr<webrtc::StreamCollectionInterface> local_streams() override { return nullptr; }
     49    rtc::scoped_refptr<webrtc::StreamCollectionInterface> remote_streams() override { return nullptr; }
     50    rtc::scoped_refptr<webrtc::DtmfSenderInterface> CreateDtmfSender(webrtc::AudioTrackInterface*) override { return nullptr; }
     51    const webrtc::SessionDescriptionInterface* local_description() const override { return nullptr; }
     52    const webrtc::SessionDescriptionInterface* remote_description() const override { return nullptr; }
     53    bool AddIceCandidate(const webrtc::IceCandidateInterface*) override { return true; }
     54    void RegisterUMAObserver(webrtc::UMAObserver*) override { }
     55    SignalingState signaling_state() override { return kStable; }
     56    IceConnectionState ice_connection_state() override { return kIceConnectionNew; }
     57    IceGatheringState ice_gathering_state() override { return kIceGatheringNew; }
     58    void StopRtcEventLog() override { }
     59    void Close() override { }
     60
     61protected:
    6462    void SetRemoteDescription(webrtc::SetSessionDescriptionObserver*, webrtc::SessionDescriptionInterface*) final;
    65     void CreateOffer(webrtc::CreateSessionDescriptionObserver*, const webrtc::MediaConstraintsInterface*) final;
    6663    void CreateAnswer(webrtc::CreateSessionDescriptionObserver*, const webrtc::MediaConstraintsInterface*) final;
    6764    rtc::scoped_refptr<webrtc::DataChannelInterface> CreateDataChannel(const std::string&, const webrtc::DataChannelInit*) final;
    6865    bool AddStream(webrtc::MediaStreamInterface*) final;
    6966    void RemoveStream(webrtc::MediaStreamInterface*) final;
     67
     68    void SetLocalDescription(webrtc::SetSessionDescriptionObserver*, webrtc::SessionDescriptionInterface*) override;
     69    bool GetStats(webrtc::StatsObserver*, webrtc::MediaStreamTrackInterface*, StatsOutputLevel) override { return false; }
     70    void CreateOffer(webrtc::CreateSessionDescriptionObserver*, const webrtc::MediaConstraintsInterface*) override;
    7071
    7172    virtual void gotLocalDescription() { }
Note: See TracChangeset for help on using the changeset viewer.