Attachment 350061 Details for Bug 189707 – Patch for landing

[patch] Patch for landing

bug-189707-20180918144539.patch (text/plain), 42.13 KB, created by youenn fablet on 2018-09-18 14:45:40 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: youenn fablet

Created: 2018-09-18 14:45:40 PDT

Size: 42.13 KB

patch

obsolete

>Subversion Revision: 236098
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 834476ba3c6511812a2648bd1057deec2183c298..5bbe5f5f99ea04ea2b0c9aa754378fd8dd8ade87 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,53 @@
>+2018-09-18  Youenn Fablet  <youenn@apple.com>
>+
>+        Implement sender/receiver getStats
>+        https://bugs.webkit.org/show_bug.cgi?id=189707
>+
>+        Reviewed by Eric Carlson.
>+
>+        Add support for sender and receiver getStats.
>+        Also add support for peer connection selector parameter.
>+
>+        Add the plumbing of the selector to LibWebRTCMediaEndpoint.
>+        Then make use of libwebrtc overloaded methods to retrieve the right stats.
>+
>+        Covered by updated/rebased tests.
>+
>+        * Modules/mediastream/PeerConnectionBackend.h:
>+        * Modules/mediastream/RTCPeerConnection.cpp:
>+        (WebCore::RTCPeerConnection::getStats):
>+        * Modules/mediastream/RTCPeerConnection.h:
>+        * Modules/mediastream/RTCPeerConnection.idl:
>+        * Modules/mediastream/RTCRtpReceiver.cpp:
>+        (WebCore::RTCRtpReceiver::RTCRtpReceiver):
>+        (WebCore::RTCRtpReceiver::getStats):
>+        * Modules/mediastream/RTCRtpReceiver.h:
>+        (WebCore::RTCRtpReceiver::create):
>+        (WebCore::RTCRtpReceiver::backend):
>+        * Modules/mediastream/RTCRtpReceiver.idl:
>+        * Modules/mediastream/RTCRtpSender.cpp:
>+        (WebCore::RTCRtpSender::create):
>+        (WebCore::RTCRtpSender::RTCRtpSender):
>+        (WebCore::RTCRtpSender::getStats):
>+        * Modules/mediastream/RTCRtpSender.h:
>+        * Modules/mediastream/RTCRtpSender.idl:
>+        * Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp:
>+        (WebCore::LibWebRTCMediaEndpoint::getStats):
>+        * Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.h:
>+        * Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp:
>+        (WebCore::LibWebRTCPeerConnectionBackend::getStats):
>+        (WebCore::backendFromRTPSender):
>+        (WebCore::createReceiverForSource):
>+        (WebCore::LibWebRTCPeerConnectionBackend::createReceiver):
>+        (WebCore::LibWebRTCPeerConnectionBackend::videoReceiver):
>+        (WebCore::LibWebRTCPeerConnectionBackend::audioReceiver):
>+        (WebCore::LibWebRTCPeerConnectionBackend::addTrack):
>+        (WebCore::LibWebRTCPeerConnectionBackend::addUnifiedPlanTransceiver):
>+        (WebCore::LibWebRTCPeerConnectionBackend::addTransceiver):
>+        (WebCore::LibWebRTCPeerConnectionBackend::newRemoteTransceiver):
>+        * Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.h:
>+        * Modules/mediastream/libwebrtc/LibWebRTCRtpReceiverBackend.h:
>+
> 2018-09-18  Youenn Fablet  <youenn@apple.com>
> 
>         Implement RTCRtpReceiver getContributingSources/getSynchronizationSources
>diff --git a/Source/WebCore/Modules/mediastream/PeerConnectionBackend.h b/Source/WebCore/Modules/mediastream/PeerConnectionBackend.h
>index 06e92722fdc4c5140d902f4d2ca484a5a3213747..652176524434d28f417e6a3b267218aba378ea3e 100644
>--- a/Source/WebCore/Modules/mediastream/PeerConnectionBackend.h
>+++ b/Source/WebCore/Modules/mediastream/PeerConnectionBackend.h
>@@ -39,6 +39,7 @@
> #include "RTCSessionDescription.h"
> #include "RTCSignalingState.h"
> #include <wtf/LoggerHelper.h>
>+#include <wtf/WeakPtr.h>
> 
> namespace WebCore {
> 
>@@ -68,8 +69,9 @@ using StatsPromise = DOMPromiseDeferred<IDLInterface<RTCStatsReport>>;
> using CreatePeerConnectionBackend = std::unique_ptr<PeerConnectionBackend> (*)(RTCPeerConnection&);
> 
> class PeerConnectionBackend
>+    : public CanMakeWeakPtr<PeerConnectionBackend>
> #if !RELEASE_LOG_DISABLED
>-    : private LoggerHelper
>+    , private LoggerHelper
> #endif
> {
> public:
>@@ -98,7 +100,9 @@ public:
> 
>     virtual bool setConfiguration(MediaEndpointConfiguration&&) = 0;
> 
>-    virtual void getStats(MediaStreamTrack*, Ref<DeferredPromise>&&) = 0;
>+    virtual void getStats(Ref<DeferredPromise>&&) = 0;
>+    virtual void getStats(RTCRtpSender&, Ref<DeferredPromise>&&) = 0;
>+    virtual void getStats(RTCRtpReceiver&, Ref<DeferredPromise>&&) = 0;
> 
>     virtual ExceptionOr<Ref<RTCRtpSender>> addTrack(MediaStreamTrack&, Vector<String>&&);
>     virtual void removeTrack(RTCRtpSender&) { }
>diff --git a/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp b/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp
>index ba2ee56211e3094e18862d58d485a8e2c03260aa..ee90075603cf754f435120c53370c47620edfe8d 100644
>--- a/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp
>+++ b/Source/WebCore/Modules/mediastream/RTCPeerConnection.cpp
>@@ -328,7 +328,19 @@ ExceptionOr<void> RTCPeerConnection::setConfiguration(RTCConfiguration&& configu
> 
> void RTCPeerConnection::getStats(MediaStreamTrack* selector, Ref<DeferredPromise>&& promise)
> {
>-    m_backend->getStats(selector, WTFMove(promise));
>+    if (selector) {
>+        for (auto& transceiver : m_transceiverSet->list()) {
>+            if (transceiver->sender().track() == selector) {
>+                m_backend->getStats(transceiver->sender(), WTFMove(promise));
>+                return;
>+            }
>+            if (&transceiver->receiver().track() == selector) {
>+                m_backend->getStats(transceiver->receiver(), WTFMove(promise));
>+                return;
>+            }
>+        }
>+    }
>+    m_backend->getStats(WTFMove(promise));
> }
> 
> ExceptionOr<Ref<RTCDataChannel>> RTCPeerConnection::createDataChannel(ScriptExecutionContext& context, String&& label, RTCDataChannelInit&& options)
>diff --git a/Source/WebCore/Modules/mediastream/RTCPeerConnection.idl b/Source/WebCore/Modules/mediastream/RTCPeerConnection.idl
>index 1f4359b95b20401fc1de2f569ea8ef9fd814f7fb..f32262b01a09167db04f6f132350af6ba0aafae6 100644
>--- a/Source/WebCore/Modules/mediastream/RTCPeerConnection.idl
>+++ b/Source/WebCore/Modules/mediastream/RTCPeerConnection.idl
>@@ -138,7 +138,6 @@ typedef RTCRtpTransceiverDirection RtpTransceiverDirection;
> 
> 
>     // 8.2 Statistics API
>-    // FIXME 169644: |selector| may go away in a future version of the spec
>     Promise<RTCStatsReport> getStats(optional MediaStreamTrack? selector = null);
> 
> 
>diff --git a/Source/WebCore/Modules/mediastream/RTCRtpReceiver.cpp b/Source/WebCore/Modules/mediastream/RTCRtpReceiver.cpp
>index 58f42cad76cda64b7f55537062e1b80482fa7b28..fb01e9cfc9f63e1b9633be8002971bf1d68aded9 100644
>--- a/Source/WebCore/Modules/mediastream/RTCRtpReceiver.cpp
>+++ b/Source/WebCore/Modules/mediastream/RTCRtpReceiver.cpp
>@@ -35,9 +35,10 @@
> 
> namespace WebCore {
> 
>-RTCRtpReceiver::RTCRtpReceiver(Ref<MediaStreamTrack>&& track, std::unique_ptr<RTCRtpReceiverBackend>&& backend)
>+RTCRtpReceiver::RTCRtpReceiver(PeerConnectionBackend& connection, Ref<MediaStreamTrack>&& track, std::unique_ptr<RTCRtpReceiverBackend>&& backend)
>     : m_track(WTFMove(track))
>     , m_backend(WTFMove(backend))
>+    , m_connection(makeWeakPtr(&connection))
> {
> }
> 
>@@ -50,6 +51,15 @@ void RTCRtpReceiver::stop()
>     m_track->stopTrack(MediaStreamTrack::StopMode::PostEvent);
> }
> 
>+void RTCRtpReceiver::getStats(Ref<DeferredPromise>&& promise)
>+{
>+    if (!m_connection) {
>+        promise->reject(InvalidStateError);
>+        return;
>+    }
>+    m_connection->getStats(*this, WTFMove(promise));
>+}
>+
> } // namespace WebCore
> 
> #endif // ENABLE(WEB_RTC)
>diff --git a/Source/WebCore/Modules/mediastream/RTCRtpReceiver.h b/Source/WebCore/Modules/mediastream/RTCRtpReceiver.h
>index 532e2c027dbad9551f0dd01f637377b2dbe8bd4d..b4fee60afc18bd596e16c4080d0cf608e4041c42 100644
>--- a/Source/WebCore/Modules/mediastream/RTCRtpReceiver.h
>+++ b/Source/WebCore/Modules/mediastream/RTCRtpReceiver.h
>@@ -39,12 +39,13 @@
> 
> namespace WebCore {
> 
>+class PeerConnectionBackend;
> 
> class RTCRtpReceiver : public RefCounted<RTCRtpReceiver>, public ScriptWrappable  {
> public:
>-    static Ref<RTCRtpReceiver> create(Ref<MediaStreamTrack>&& track, std::unique_ptr<RTCRtpReceiverBackend>&& backend)
>+    static Ref<RTCRtpReceiver> create(PeerConnectionBackend& connection, Ref<MediaStreamTrack>&& track, std::unique_ptr<RTCRtpReceiverBackend>&& backend)
>     {
>-        return adoptRef(*new RTCRtpReceiver(WTFMove(track), WTFMove(backend)));
>+        return adoptRef(*new RTCRtpReceiver(connection, WTFMove(track), WTFMove(backend)));
>     }
> 
>     void stop();
>@@ -56,11 +57,15 @@ public:
> 
>     MediaStreamTrack& track() { return m_track.get(); }
> 
>+    RTCRtpReceiverBackend* backend() { return m_backend.get(); }
>+    void getStats(Ref<DeferredPromise>&&);
>+
> private:
>-    RTCRtpReceiver(Ref<MediaStreamTrack>&&, std::unique_ptr<RTCRtpReceiverBackend>&&);
>+    RTCRtpReceiver(PeerConnectionBackend&, Ref<MediaStreamTrack>&&, std::unique_ptr<RTCRtpReceiverBackend>&&);
> 
>     Ref<MediaStreamTrack> m_track;
>     std::unique_ptr<RTCRtpReceiverBackend> m_backend;
>+    WeakPtr<PeerConnectionBackend> m_connection;
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/Modules/mediastream/RTCRtpReceiver.idl b/Source/WebCore/Modules/mediastream/RTCRtpReceiver.idl
>index 9f53d5d538822488ad1d65e5a68f84bcd2c88eac..9d8565a76d0da90d738fcc6dbe54c0fda374c608 100644
>--- a/Source/WebCore/Modules/mediastream/RTCRtpReceiver.idl
>+++ b/Source/WebCore/Modules/mediastream/RTCRtpReceiver.idl
>@@ -41,4 +41,5 @@
>     // FIXME 169662: missing getCapabilities
>     sequence<RTCRtpContributingSource> getContributingSources();
>     sequence<RTCRtpSynchronizationSource> getSynchronizationSources();
>+    Promise<RTCStatsReport> getStats();
> };
>diff --git a/Source/WebCore/Modules/mediastream/RTCRtpSender.cpp b/Source/WebCore/Modules/mediastream/RTCRtpSender.cpp
>index 7ebddd9708133e43ea312192d18402e0c0a076ec..c7ca2b4f27d9959fb31155447b1a9f6e5753777d 100644
>--- a/Source/WebCore/Modules/mediastream/RTCRtpSender.cpp
>+++ b/Source/WebCore/Modules/mediastream/RTCRtpSender.cpp
>@@ -37,22 +37,23 @@
> 
> namespace WebCore {
> 
>-Ref<RTCRtpSender> RTCRtpSender::create(Ref<MediaStreamTrack>&& track, Vector<String>&& mediaStreamIds, std::unique_ptr<RTCRtpSenderBackend>&& backend)
>+Ref<RTCRtpSender> RTCRtpSender::create(PeerConnectionBackend& connection, Ref<MediaStreamTrack>&& track, Vector<String>&& mediaStreamIds, std::unique_ptr<RTCRtpSenderBackend>&& backend)
> {
>-    auto sender = adoptRef(*new RTCRtpSender(String(track->kind()), WTFMove(mediaStreamIds), WTFMove(backend)));
>+    auto sender = adoptRef(*new RTCRtpSender(connection, String(track->kind()), WTFMove(mediaStreamIds), WTFMove(backend)));
>     sender->setTrack(WTFMove(track));
>     return sender;
> }
> 
>-Ref<RTCRtpSender> RTCRtpSender::create(String&& trackKind, Vector<String>&& mediaStreamIds, std::unique_ptr<RTCRtpSenderBackend>&& backend)
>+Ref<RTCRtpSender> RTCRtpSender::create(PeerConnectionBackend& connection, String&& trackKind, Vector<String>&& mediaStreamIds, std::unique_ptr<RTCRtpSenderBackend>&& backend)
> {
>-    return adoptRef(*new RTCRtpSender(WTFMove(trackKind), WTFMove(mediaStreamIds), WTFMove(backend)));
>+    return adoptRef(*new RTCRtpSender(connection, WTFMove(trackKind), WTFMove(mediaStreamIds), WTFMove(backend)));
> }
> 
>-RTCRtpSender::RTCRtpSender(String&& trackKind, Vector<String>&& mediaStreamIds, std::unique_ptr<RTCRtpSenderBackend>&& backend)
>+RTCRtpSender::RTCRtpSender(PeerConnectionBackend& connection, String&& trackKind, Vector<String>&& mediaStreamIds, std::unique_ptr<RTCRtpSenderBackend>&& backend)
>     : m_trackKind(WTFMove(trackKind))
>     , m_mediaStreamIds(WTFMove(mediaStreamIds))
>     , m_backend(WTFMove(backend))
>+    , m_connection(makeWeakPtr(&connection))
> {
>     ASSERT(!RuntimeEnabledFeatures::sharedFeatures().webRTCUnifiedPlanEnabled() || m_backend);
> }
>@@ -110,6 +111,15 @@ void RTCRtpSender::setParameters(const RTCRtpSendParameters& parameters, DOMProm
>     return m_backend->setParameters(parameters, WTFMove(promise));
> }
> 
>+void RTCRtpSender::getStats(Ref<DeferredPromise>&& promise)
>+{
>+    if (!m_connection) {
>+        promise->reject(InvalidStateError);
>+        return;
>+    }
>+    m_connection->getStats(*this, WTFMove(promise));
>+}
>+
> } // namespace WebCore
> 
> #endif // ENABLE(WEB_RTC)
>diff --git a/Source/WebCore/Modules/mediastream/RTCRtpSender.h b/Source/WebCore/Modules/mediastream/RTCRtpSender.h
>index 20bbfde18c287543ff51f43c5dd79ae23ee1d300..49aad3e3344fde6acca46edc9aae687d31e77d66 100644
>--- a/Source/WebCore/Modules/mediastream/RTCRtpSender.h
>+++ b/Source/WebCore/Modules/mediastream/RTCRtpSender.h
>@@ -39,10 +39,12 @@
> 
> namespace WebCore {
> 
>+class PeerConnectionBackend;
>+
> class RTCRtpSender : public RefCounted<RTCRtpSender>, public ScriptWrappable {
> public:
>-    static Ref<RTCRtpSender> create(Ref<MediaStreamTrack>&&, Vector<String>&& mediaStreamIds, std::unique_ptr<RTCRtpSenderBackend>&&);
>-    static Ref<RTCRtpSender> create(String&& trackKind, Vector<String>&& mediaStreamIds, std::unique_ptr<RTCRtpSenderBackend>&&);
>+    static Ref<RTCRtpSender> create(PeerConnectionBackend&, Ref<MediaStreamTrack>&&, Vector<String>&& mediaStreamIds, std::unique_ptr<RTCRtpSenderBackend>&&);
>+    static Ref<RTCRtpSender> create(PeerConnectionBackend&, String&& trackKind, Vector<String>&& mediaStreamIds, std::unique_ptr<RTCRtpSenderBackend>&&);
> 
>     MediaStreamTrack* track() { return m_track.get(); }
> 
>@@ -64,14 +66,17 @@ public:
> 
>     RTCRtpSenderBackend* backend() { return m_backend.get(); }
> 
>+    void getStats(Ref<DeferredPromise>&&);
>+
> private:
>-    RTCRtpSender(String&& trackKind, Vector<String>&& mediaStreamIds, std::unique_ptr<RTCRtpSenderBackend>&&);
>+    RTCRtpSender(PeerConnectionBackend&, String&& trackKind, Vector<String>&& mediaStreamIds, std::unique_ptr<RTCRtpSenderBackend>&&);
> 
>     RefPtr<MediaStreamTrack> m_track;
>     String m_trackId;
>     String m_trackKind;
>     Vector<String> m_mediaStreamIds;
>     std::unique_ptr<RTCRtpSenderBackend> m_backend;
>+    WeakPtr<PeerConnectionBackend> m_connection;
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/Modules/mediastream/RTCRtpSender.idl b/Source/WebCore/Modules/mediastream/RTCRtpSender.idl
>index 91f65b323967d7a5ea83c1d67aaaa3ab79b2fee0..09cdb8e345993ce98d6bd359cc2b366c7ee2122d 100644
>--- a/Source/WebCore/Modules/mediastream/RTCRtpSender.idl
>+++ b/Source/WebCore/Modules/mediastream/RTCRtpSender.idl
>@@ -42,4 +42,5 @@
>     RTCRtpSendParameters getParameters();
>     Promise<void> setParameters(RTCRtpSendParameters parameters);
>     [CallWith=ScriptExecutionContext] Promise<void> replaceTrack(MediaStreamTrack? withTrack);
>+    Promise<RTCStatsReport> getStats();
> };
>diff --git a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp
>index b25b564f2be71ae2ea5db0e9d39fbdfdb8e07e28..cd00353838c2f7673390d3c2428dc0ef40c46887 100644
>--- a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp
>+++ b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.cpp
>@@ -277,7 +277,7 @@ void LibWebRTCMediaEndpoint::doCreateAnswer()
>     m_backend->CreateAnswer(&m_createSessionDescriptionObserver, nullptr);
> }
> 
>-void LibWebRTCMediaEndpoint::getStats(MediaStreamTrack*, Ref<DeferredPromise>&& promise)
>+void LibWebRTCMediaEndpoint::getStats(Ref<DeferredPromise>&& promise, WTF::Function<void(rtc::scoped_refptr<LibWebRTCStatsCollector>&&)>&& getStatsFunction)
> {
>     auto collector = LibWebRTCStatsCollector::create([promise = WTFMove(promise), protectedThis = makeRef(*this)](auto&& report) mutable {
>         ASSERT(isMainThread());
>@@ -287,9 +287,32 @@ void LibWebRTCMediaEndpoint::getStats(MediaStreamTrack*, Ref<DeferredPromise>&&
>         promise->resolve<IDLInterface<RTCStatsReport>>(report.releaseNonNull());
>         return true;
>     });
>-    LibWebRTCProvider::callOnWebRTCSignalingThread([this, collector = WTFMove(collector)] {
>+    LibWebRTCProvider::callOnWebRTCSignalingThread([getStatsFunction = WTFMove(getStatsFunction), collector = WTFMove(collector)]() mutable {
>+        getStatsFunction(WTFMove(collector));
>+    });
>+}
>+
>+void LibWebRTCMediaEndpoint::getStats(Ref<DeferredPromise>&& promise)
>+{
>+    getStats(WTFMove(promise), [this](auto&& collector) {
>+        if (m_backend)
>+            m_backend->GetStats(WTFMove(collector));
>+    });
>+}
>+
>+void LibWebRTCMediaEndpoint::getStats(webrtc::RtpReceiverInterface& receiver, Ref<DeferredPromise>&& promise)
>+{
>+    getStats(WTFMove(promise), [this, receiver = rtc::scoped_refptr<webrtc::RtpReceiverInterface>(&receiver)](auto&& collector) mutable {
>+        if (m_backend)
>+            m_backend->GetStats(WTFMove(receiver), WTFMove(collector));
>+    });
>+}
>+
>+void LibWebRTCMediaEndpoint::getStats(webrtc::RtpSenderInterface& sender, Ref<DeferredPromise>&& promise)
>+{
>+    getStats(WTFMove(promise), [this, sender = rtc::scoped_refptr<webrtc::RtpSenderInterface>(&sender)](auto&& collector)  mutable {
>         if (m_backend)
>-            m_backend->GetStats(collector.get());
>+            m_backend->GetStats(WTFMove(sender), WTFMove(collector));
>     });
> }
> 
>diff --git a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.h b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.h
>index 177e7aa143f67d9c26975170e785c43640dc39cd..efb511312584a59d70a46cccee0477b125ba2a0a 100644
>--- a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.h
>+++ b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCMediaEndpoint.h
>@@ -55,11 +55,11 @@ class SetSessionDescriptionObserver;
> }
> 
> namespace WebCore {
>-
> class LibWebRTCProvider;
> class LibWebRTCPeerConnectionBackend;
> class LibWebRTCRtpReceiverBackend;
> class LibWebRTCRtpTransceiverBackend;
>+class LibWebRTCStatsCollector;
> class MediaStreamTrack;
> class RTCSessionDescription;
> 
>@@ -82,7 +82,9 @@ public:
>     void doSetRemoteDescription(RTCSessionDescription&);
>     void doCreateOffer(const RTCOfferOptions&);
>     void doCreateAnswer();
>-    void getStats(MediaStreamTrack*, Ref<DeferredPromise>&&);
>+    void getStats(Ref<DeferredPromise>&&);
>+    void getStats(webrtc::RtpReceiverInterface&, Ref<DeferredPromise>&&);
>+    void getStats(webrtc::RtpSenderInterface&, Ref<DeferredPromise>&&);
>     std::unique_ptr<RTCDataChannelHandler> createDataChannel(const String&, const RTCDataChannelInit&);
>     bool addIceCandidate(webrtc::IceCandidateInterface& candidate) { return m_backend->AddIceCandidate(&candidate); }
> 
>@@ -148,6 +150,8 @@ private:
>     void startLoggingStats();
>     void stopLoggingStats();
> 
>+    void getStats(Ref<DeferredPromise>&&, WTF::Function<void(rtc::scoped_refptr<LibWebRTCStatsCollector>&&)>&&);
>+
>     MediaStream& mediaStreamFromRTCStream(webrtc::MediaStreamInterface&);
> 
>     void AddRef() const { ref(); }
>diff --git a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp
>index 3c4f99a5b32f6fafd8af3542c4eabe2be0134978..42053b0c6813776f2a3c938fa53774e5d1ea4170 100644
>--- a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp
>+++ b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.cpp
>@@ -129,9 +129,37 @@ bool LibWebRTCPeerConnectionBackend::setConfiguration(MediaEndpointConfiguration
>     return m_endpoint->setConfiguration(page->libWebRTCProvider(), configurationFromMediaEndpointConfiguration(WTFMove(configuration)));
> }
> 
>-void LibWebRTCPeerConnectionBackend::getStats(MediaStreamTrack* track, Ref<DeferredPromise>&& promise)
>+void LibWebRTCPeerConnectionBackend::getStats(Ref<DeferredPromise>&& promise)
> {
>-    m_endpoint->getStats(track, WTFMove(promise));
>+    m_endpoint->getStats(WTFMove(promise));
>+}
>+
>+static inline LibWebRTCRtpSenderBackend& backendFromRTPSender(RTCRtpSender& sender)
>+{
>+    ASSERT(!sender.isStopped());
>+    return static_cast<LibWebRTCRtpSenderBackend&>(*sender.backend());
>+}
>+
>+void LibWebRTCPeerConnectionBackend::getStats(RTCRtpSender& sender, Ref<DeferredPromise>&& promise)
>+{
>+    webrtc::RtpSenderInterface* rtcSender = sender.backend() ? backendFromRTPSender(sender).rtcSender() : nullptr;
>+
>+    if (!rtcSender) {
>+        m_endpoint->getStats(WTFMove(promise));
>+        return;
>+    }
>+    m_endpoint->getStats(*rtcSender, WTFMove(promise));
>+}
>+
>+void LibWebRTCPeerConnectionBackend::getStats(RTCRtpReceiver& receiver, Ref<DeferredPromise>&& promise)
>+{
>+    webrtc::RtpReceiverInterface* rtcReceiver = receiver.backend() ? static_cast<LibWebRTCRtpReceiverBackend*>(receiver.backend())->rtcReceiver() : nullptr;
>+
>+    if (!rtcReceiver) {
>+        m_endpoint->getStats(WTFMove(promise));
>+        return;
>+    }
>+    m_endpoint->getStats(*rtcReceiver, WTFMove(promise));
> }
> 
> void LibWebRTCPeerConnectionBackend::doSetLocalDescription(RTCSessionDescription& description)
>@@ -201,12 +229,12 @@ void LibWebRTCPeerConnectionBackend::doAddIceCandidate(RTCIceCandidate& candidat
>     addIceCandidateSucceeded();
> }
> 
>-static inline Ref<RTCRtpReceiver> createReceiverForSource(ScriptExecutionContext& context, Ref<RealtimeMediaSource>&& source, std::unique_ptr<RTCRtpReceiverBackend>&& backend)
>+Ref<RTCRtpReceiver> LibWebRTCPeerConnectionBackend::createReceiverForSource(Ref<RealtimeMediaSource>&& source, std::unique_ptr<RTCRtpReceiverBackend>&& backend)
> {
>     auto remoteTrackPrivate = MediaStreamTrackPrivate::create(WTFMove(source), String { source->id() });
>-    auto remoteTrack = MediaStreamTrack::create(context, WTFMove(remoteTrackPrivate));
>+    auto remoteTrack = MediaStreamTrack::create(*m_peerConnection.scriptExecutionContext(), WTFMove(remoteTrackPrivate));
> 
>-    return RTCRtpReceiver::create(WTFMove(remoteTrack), WTFMove(backend));
>+    return RTCRtpReceiver::create(*this, WTFMove(remoteTrack), WTFMove(backend));
> }
> 
> static inline Ref<RealtimeMediaSource> createEmptySource(const String& trackKind, String&& trackId)
>@@ -220,7 +248,7 @@ static inline Ref<RealtimeMediaSource> createEmptySource(const String& trackKind
> 
> Ref<RTCRtpReceiver> LibWebRTCPeerConnectionBackend::createReceiver(const String& trackKind, const String& trackId)
> {
>-    auto receiver = createReceiverForSource(*m_peerConnection.scriptExecutionContext(), createEmptySource(trackKind, String(trackId)), nullptr);
>+    auto receiver = createReceiverForSource(createEmptySource(trackKind, String(trackId)), nullptr);
>     m_pendingReceivers.append(receiver.copyRef());
>     return receiver;
> }
>@@ -238,10 +266,10 @@ LibWebRTCPeerConnectionBackend::VideoReceiver LibWebRTCPeerConnectionBackend::vi
>         }
>     }
>     auto source = RealtimeIncomingVideoSource::create(nullptr, WTFMove(trackId));
>-    auto receiver = createReceiverForSource(*m_peerConnection.scriptExecutionContext(), source.copyRef(), nullptr);
>+    auto receiver = createReceiverForSource(source.copyRef(), nullptr);
> 
>     auto senderBackend = std::make_unique<LibWebRTCRtpSenderBackend>(*this, nullptr);
>-    auto transceiver = RTCRtpTransceiver::create(RTCRtpSender::create("video", { }, WTFMove(senderBackend)), receiver.copyRef(), nullptr);
>+    auto transceiver = RTCRtpTransceiver::create(RTCRtpSender::create(*this, "video"_s, { }, WTFMove(senderBackend)), receiver.copyRef(), nullptr);
>     transceiver->disableSendingDirection();
>     m_peerConnection.addTransceiver(WTFMove(transceiver));
> 
>@@ -261,10 +289,10 @@ LibWebRTCPeerConnectionBackend::AudioReceiver LibWebRTCPeerConnectionBackend::au
>         }
>     }
>     auto source = RealtimeIncomingAudioSource::create(nullptr, WTFMove(trackId));
>-    auto receiver = createReceiverForSource(*m_peerConnection.scriptExecutionContext(), source.copyRef(), nullptr);
>+    auto receiver = createReceiverForSource(source.copyRef(), nullptr);
> 
>     auto senderBackend = std::make_unique<LibWebRTCRtpSenderBackend>(*this, nullptr);
>-    auto transceiver = RTCRtpTransceiver::create(RTCRtpSender::create("audio", { }, WTFMove(senderBackend)), receiver.copyRef(), nullptr);
>+    auto transceiver = RTCRtpTransceiver::create(RTCRtpSender::create(*this, "audio"_, { }, WTFMove(senderBackend)), receiver.copyRef(), nullptr);
>     transceiver->disableSendingDirection();
>     m_peerConnection.addTransceiver(WTFMove(transceiver));
> 
>@@ -315,13 +343,6 @@ RefPtr<RTCSessionDescription> LibWebRTCPeerConnectionBackend::remoteDescription(
>     return m_endpoint->remoteDescription();
> }
> 
>-static inline LibWebRTCRtpSenderBackend& backendFromRTPSender(RTCRtpSender& sender)
>-{
>-    ASSERT(!sender.isStopped());
>-    return static_cast<LibWebRTCRtpSenderBackend&>(*sender.backend());
>-}
>-
>-
> static inline RefPtr<RTCRtpSender> findExistingSender(const Vector<std::reference_wrapper<RTCRtpSender>>& senders, LibWebRTCRtpSenderBackend& senderBackend)
> {
>     ASSERT(senderBackend.rtcSender());
>@@ -347,8 +368,8 @@ ExceptionOr<Ref<RTCRtpSender>> LibWebRTCPeerConnectionBackend::addTrack(MediaStr
> 
>         auto transceiverBackend = m_endpoint->transceiverBackendFromSender(*senderBackend);
> 
>-        auto sender = RTCRtpSender::create(makeRef(track), WTFMove(mediaStreamIds), WTFMove(senderBackend));
>-        auto receiver = createReceiverForSource(*m_peerConnection.scriptExecutionContext(), createEmptySource(track.kind(), createCanonicalUUIDString()), transceiverBackend->createReceiverBackend());
>+        auto sender = RTCRtpSender::create(*this, makeRef(track), WTFMove(mediaStreamIds), WTFMove(senderBackend));
>+        auto receiver = createReceiverForSource(createEmptySource(track.kind(), createCanonicalUUIDString()), transceiverBackend->createReceiverBackend());
>         auto transceiver = RTCRtpTransceiver::create(sender.copyRef(), WTFMove(receiver), WTFMove(transceiverBackend));
>         m_peerConnection.addInternalTransceiver(WTFMove(transceiver));
>         return WTFMove(sender);
>@@ -373,7 +394,7 @@ ExceptionOr<Ref<RTCRtpSender>> LibWebRTCPeerConnectionBackend::addTrack(MediaStr
>         String trackId = createCanonicalUUIDString();
> 
>         auto senderBackend = std::make_unique<LibWebRTCRtpSenderBackend>(*this, nullptr);
>-        auto newSender = RTCRtpSender::create(makeRef(track), Vector<String> { mediaStreamIds }, WTFMove(senderBackend));
>+        auto newSender = RTCRtpSender::create(*this, makeRef(track), Vector<String> { mediaStreamIds }, WTFMove(senderBackend));
>         auto receiver = createReceiver(trackKind, trackId);
>         auto transceiver = RTCRtpTransceiver::create(WTFMove(newSender), WTFMove(receiver), nullptr);
> 
>@@ -394,8 +415,8 @@ ExceptionOr<Ref<RTCRtpTransceiver>> LibWebRTCPeerConnectionBackend::addUnifiedPl
>     if (!backends)
>         return Exception { InvalidAccessError, "Unable to add transceiver"_s };
> 
>-    auto sender = RTCRtpSender::create(WTFMove(trackOrKind), Vector<String> { }, WTFMove(backends->senderBackend));
>-    auto receiver = createReceiverForSource(*m_peerConnection.scriptExecutionContext(), createEmptySource(sender->trackKind(), createCanonicalUUIDString()), WTFMove(backends->receiverBackend));
>+    auto sender = RTCRtpSender::create(*this, WTFMove(trackOrKind), Vector<String> { }, WTFMove(backends->senderBackend));
>+    auto receiver = createReceiverForSource(createEmptySource(sender->trackKind(), createCanonicalUUIDString()), WTFMove(backends->receiverBackend));
>     auto transceiver = RTCRtpTransceiver::create(WTFMove(sender), WTFMove(receiver), WTFMove(backends->transceiverBackend));
>     m_peerConnection.addInternalTransceiver(transceiver.copyRef());
>     return WTFMove(transceiver);
>@@ -407,7 +428,7 @@ ExceptionOr<Ref<RTCRtpTransceiver>> LibWebRTCPeerConnectionBackend::addTransceiv
>         return addUnifiedPlanTransceiver(String { trackKind }, init);
> 
>     auto senderBackend = std::make_unique<LibWebRTCRtpSenderBackend>(*this, nullptr);
>-    auto newSender = RTCRtpSender::create(String(trackKind), Vector<String>(), WTFMove(senderBackend));
>+    auto newSender = RTCRtpSender::create(*this, String(trackKind), Vector<String>(), WTFMove(senderBackend));
>     return completeAddTransceiver(WTFMove(newSender), init, createCanonicalUUIDString(), trackKind);
> }
> 
>@@ -418,7 +439,7 @@ ExceptionOr<Ref<RTCRtpTransceiver>> LibWebRTCPeerConnectionBackend::addTransceiv
> 
>     auto senderBackend = std::make_unique<LibWebRTCRtpSenderBackend>(*this, nullptr);
>     auto& backend = *senderBackend;
>-    auto sender = RTCRtpSender::create(track.copyRef(), Vector<String>(), WTFMove(senderBackend));
>+    auto sender = RTCRtpSender::create(*this, track.copyRef(), Vector<String>(), WTFMove(senderBackend));
>     if (!m_endpoint->addTrack(backend, track, Vector<String> { }))
>         return Exception { InvalidAccessError, "Unable to add track"_s };
> 
>@@ -441,8 +462,8 @@ RTCRtpTransceiver* LibWebRTCPeerConnectionBackend::existingTransceiver(WTF::Func
> 
> RTCRtpTransceiver& LibWebRTCPeerConnectionBackend::newRemoteTransceiver(std::unique_ptr<LibWebRTCRtpTransceiverBackend>&& transceiverBackend, Ref<RealtimeMediaSource>&& receiverSource)
> {
>-    auto sender = RTCRtpSender::create(receiverSource->type() == RealtimeMediaSource::Type::Audio ? "audio"_s : "video"_s, Vector<String> { }, transceiverBackend->createSenderBackend(*this, nullptr));
>-    auto receiver = createReceiverForSource(*m_peerConnection.scriptExecutionContext(), WTFMove(receiverSource), transceiverBackend->createReceiverBackend());
>+    auto sender = RTCRtpSender::create(*this, receiverSource->type() == RealtimeMediaSource::Type::Audio ? "audio"_s : "video"_s, Vector<String> { }, transceiverBackend->createSenderBackend(*this, nullptr));
>+    auto receiver = createReceiverForSource(WTFMove(receiverSource), transceiverBackend->createReceiverBackend());
>     auto transceiver = RTCRtpTransceiver::create(WTFMove(sender), WTFMove(receiver), WTFMove(transceiverBackend));
>     m_peerConnection.addInternalTransceiver(transceiver.copyRef());
>     return transceiver.get();
>diff --git a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.h b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.h
>index 1f6850d1752325a114b7944745ab15f247ae19c3..5ec79180602278071f3f7328d53fa8cdef168730 100644
>--- a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.h
>+++ b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCPeerConnectionBackend.h
>@@ -28,7 +28,6 @@
> 
> #include "PeerConnectionBackend.h"
> #include <wtf/HashMap.h>
>-#include <wtf/WeakPtr.h>
> 
> namespace webrtc {
> class IceCandidateInterface;
>@@ -40,6 +39,7 @@ class LibWebRTCMediaEndpoint;
> class LibWebRTCProvider;
> class LibWebRTCRtpTransceiverBackend;
> class RTCRtpReceiver;
>+class RTCRtpReceiverBackend;
> class RTCSessionDescription;
> class RTCStatsReport;
> class RealtimeIncomingAudioSource;
>@@ -48,7 +48,7 @@ class RealtimeMediaSource;
> class RealtimeOutgoingAudioSource;
> class RealtimeOutgoingVideoSource;
> 
>-class LibWebRTCPeerConnectionBackend final : public PeerConnectionBackend, public CanMakeWeakPtr<LibWebRTCPeerConnectionBackend> {
>+class LibWebRTCPeerConnectionBackend final : public PeerConnectionBackend {
>     WTF_MAKE_FAST_ALLOCATED;
> public:
>     LibWebRTCPeerConnectionBackend(RTCPeerConnection&, LibWebRTCProvider&);
>@@ -67,7 +67,9 @@ private:
>     void doStop() final;
>     std::unique_ptr<RTCDataChannelHandler> createDataChannelHandler(const String&, const RTCDataChannelInit&) final;
>     bool setConfiguration(MediaEndpointConfiguration&&) final;
>-    void getStats(MediaStreamTrack*, Ref<DeferredPromise>&&) final;
>+    void getStats(Ref<DeferredPromise>&&) final;
>+    void getStats(RTCRtpSender&, Ref<DeferredPromise>&&) final;
>+    void getStats(RTCRtpReceiver&, Ref<DeferredPromise>&&) final;
> 
>     RefPtr<RTCSessionDescription> localDescription() const final;
>     RefPtr<RTCSessionDescription> currentLocalDescription() const final;
>@@ -116,6 +118,8 @@ private:
>     template<typename T>
>     ExceptionOr<Ref<RTCRtpTransceiver>> addUnifiedPlanTransceiver(T&& trackOrKind, const RTCRtpTransceiverInit&);
> 
>+    Ref<RTCRtpReceiver> createReceiverForSource(Ref<RealtimeMediaSource>&&, std::unique_ptr<RTCRtpReceiverBackend>&&);
>+
>     Ref<LibWebRTCMediaEndpoint> m_endpoint;
>     bool m_isLocalDescriptionSet { false };
>     bool m_isRemoteDescriptionSet { false };
>diff --git a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCRtpReceiverBackend.h b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCRtpReceiverBackend.h
>index fd0d95ec32975c16a53c4812f1379ae73431bae7..3124323d346f1053b3f714dcffad429d00ab4e5e 100644
>--- a/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCRtpReceiverBackend.h
>+++ b/Source/WebCore/Modules/mediastream/libwebrtc/LibWebRTCRtpReceiverBackend.h
>@@ -45,6 +45,8 @@ public:
>     {
>     }
> 
>+    webrtc::RtpReceiverInterface* rtcReceiver() { return m_rtcReceiver.get(); }
>+
> private:
>     RTCRtpParameters getParameters() final;
>     Vector<RTCRtpContributingSource> getContributingSources() const final;
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index 4c2272a0ca4598d49b80c8719dcc56067f0d6a04..391725f00ae7bd3e771cd70f386a888cae9c1e25 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,13 @@
>+2018-09-18  Youenn Fablet  <youenn@apple.com>
>+
>+        Implement sender/receiver getStats
>+        https://bugs.webkit.org/show_bug.cgi?id=189707
>+
>+        Reviewed by Eric Carlson.
>+
>+        * webrtc/video-stats-expected.txt:
>+        * webrtc/video-stats.html:
>+
> 2018-09-18  Youenn Fablet  <youenn@apple.com>
> 
>         Layout Test webrtc/video-mute.html is flaky.
>diff --git a/LayoutTests/imported/w3c/ChangeLog b/LayoutTests/imported/w3c/ChangeLog
>index 6f830817faa2c5cdd66912df7442eae6b47f955e..75a27c46c3b7171e0773ec9579e67d0f2b5e2056 100644
>--- a/LayoutTests/imported/w3c/ChangeLog
>+++ b/LayoutTests/imported/w3c/ChangeLog
>@@ -1,3 +1,13 @@
>+2018-09-18  Youenn Fablet  <youenn@apple.com>
>+
>+        Implement sender/receiver getStats
>+        https://bugs.webkit.org/show_bug.cgi?id=189707
>+
>+        Reviewed by Eric Carlson.
>+
>+        * web-platform-tests/webrtc/RTCRtpReceiver-getStats.https-expected.txt:
>+        * web-platform-tests/webrtc/RTCRtpSender-getStats.https-expected.txt:
>+
> 2018-09-18  Youenn Fablet  <youenn@apple.com>
> 
>         Implement RTCRtpReceiver getContributingSources/getSynchronizationSources
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCRtpReceiver-getStats.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCRtpReceiver-getStats.https-expected.txt
>index ecb88a2fdec021202b5dbb504a90e13d479eed82..4ee77a4270a263d32f6b9de0daf141602b66b9c2 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCRtpReceiver-getStats.https-expected.txt
>+++ b/LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCRtpReceiver-getStats.https-expected.txt
>@@ -1,4 +1,4 @@
> 
>-FAIL receiver.getStats() via addTransceiver should return stats report containing inbound-rtp stats promise_test: Unhandled rejection with value: object "TypeError: receiver.getStats is not a function. (In 'receiver.getStats()', 'receiver.getStats' is undefined)"
>-FAIL receiver.getStats() via addTrack should return stats report containing inbound-rtp stats promise_test: Unhandled rejection with value: object "TypeError: receiver.getStats is not a function. (In 'receiver.getStats()', 'receiver.getStats' is undefined)"
>+FAIL receiver.getStats() via addTransceiver should return stats report containing inbound-rtp stats assert_true: Expect statsReport to contain stats object of type inbound-rtp expected true got false
>+FAIL receiver.getStats() via addTrack should return stats report containing inbound-rtp stats assert_equals: Expect dictionary.mediaType to be string expected "string" but got "undefined"
> 
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCRtpSender-getStats.https-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCRtpSender-getStats.https-expected.txt
>index 8bbc38e21057861f22d6ced6343aa21f8576f221..8e98e4556910376cb8079c27d40cd39ca8e451b9 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCRtpSender-getStats.https-expected.txt
>+++ b/LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCRtpSender-getStats.https-expected.txt
>@@ -1,4 +1,4 @@
> 
>-FAIL sender.getStats() via addTransceiver should return stats report containing outbound-rtp stats promise_test: Unhandled rejection with value: object "TypeError: sender.getStats is not a function. (In 'sender.getStats()', 'sender.getStats' is undefined)"
>-FAIL sender.getStats() via addTrack should return stats report containing outbound-rtp stats promise_test: Unhandled rejection with value: object "TypeError: sender.getStats is not a function. (In 'sender.getStats()', 'sender.getStats' is undefined)"
>+FAIL sender.getStats() via addTransceiver should return stats report containing outbound-rtp stats assert_true: Expect statsReport to contain stats object of type outbound-rtp expected true got false
>+FAIL sender.getStats() via addTrack should return stats report containing outbound-rtp stats assert_equals: Expect dictionary.trackId to be string expected "string" but got "undefined"
> 
>diff --git a/LayoutTests/webrtc/video-stats-expected.txt b/LayoutTests/webrtc/video-stats-expected.txt
>index 242a4a5371ae79769e82f54040e04e106293e765..ef1b227ceafe82eeb6b04e461e2cb3f8c02b9ef5 100644
>--- a/LayoutTests/webrtc/video-stats-expected.txt
>+++ b/LayoutTests/webrtc/video-stats-expected.txt
>@@ -1,3 +1,5 @@
> 
> PASS Basic video stats 
>+PASS Sender stats 
>+PASS Receiver stats 
> 
>diff --git a/LayoutTests/webrtc/video-stats.html b/LayoutTests/webrtc/video-stats.html
>index 52a766a6f5b5eab0e57c12e4809b23517c692738..8286ca75abdbe1a4b3849dc50e0b0d49014220e2 100644
>--- a/LayoutTests/webrtc/video-stats.html
>+++ b/LayoutTests/webrtc/video-stats.html
>@@ -96,55 +96,76 @@ function checkOutboundFramesNumberIncreased(firstConnection, statsFirstConnectio
> }
> 
> var firstConnection, secondConnection;
>-promise_test((test) => {
>+promise_test(async (test) => {
>     if (window.testRunner)
>         testRunner.setUserMediaPermission(true);
> 
>-    var localStream, remoteStream;
>-    return navigator.mediaDevices.getUserMedia({ video: true}).then((stream) => {
>-        localStream = stream;
>-        return new Promise((resolve, reject) => {
>-            createConnections((connection) => {
>-                firstConnection = connection;
>-                firstConnection.addTrack(stream.getVideoTracks()[0], stream);
>-            }, (connection) => {
>-                secondConnection = connection;
>-                secondConnection.ontrack = (trackEvent) => {
>-                    remoteStream = trackEvent.streams[0];
>-                    resolve();
>-                };
>-            });
>-            setTimeout(() => reject("Test timed out"), 5000);
>+    const localStream = await navigator.mediaDevices.getUserMedia({ video: true});
>+    await new Promise((resolve, reject) => {
>+        createConnections((connection) => {
>+            firstConnection = connection;
>+            firstConnection.addTrack(localStream.getVideoTracks()[0], localStream);
>+        }, (connection) => {
>+            secondConnection = connection;
>+            secondConnection.addTrack(localStream.getVideoTracks()[0], localStream);
>+            secondConnection.ontrack = (trackEvent) => {
>+                resolve();
>+            };
>         });
>-    }).then(() => {
>-        return getOutboundRTPStats(firstConnection);
>-    }).then((stats) => {
>-        assert_true(!!stats, "outbound-rtp stats should not be null");
>-        assert_true(Number.isInteger(stats.framesEncoded), "framesEncoded should be an integer");
>-        assert_true(Number.isInteger(stats.qpSum), "outbound qpSum should be an integer");
>-        assert_true(typeof stats.timestamp === "number", "timestamp should be a double");
>-        statsFirstConnection = stats;
>-        return getInboundRTPStats(secondConnection);
>-    }).then((stats) => {
>-        assert_true(!!stats, "inbound-rtp stats should not be null");
>-        assert_true(Number.isInteger(stats.framesDecoded), "framesDecoded should be an integer");
>-        assert_true(Number.isInteger(stats.qpSum), "inbound qpSum should be an integer");
>-        assert_true(typeof stats.timestamp === "number", "timestamp should be a double");
>-        statsSecondConnection = stats;
>-    }).then(() => {
>-        return checkInboundFramesNumberIncreased(secondConnection, statsSecondConnection, 0);
>-    }).then(() => {
>-        return checkOutboundFramesNumberIncreased(firstConnection, statsFirstConnection, 0);
>-    }).then(() => {
>-        return getStatsType(firstConnection);
>-    }).then((types) => {
>-        assert_array_equals(types, ["candidate-pair", "certificate", "outbound-rtp", "track"]);
>-    }).then(() => {
>-        return getStatsType(secondConnection);
>-    }).then((types) => {
>-        assert_array_equals(types, ["candidate-pair", "certificate", "inbound-rtp", "track"]);
>+        setTimeout(() => reject("Test timed out"), 5000);
>     });
>+
>+    let stats = await getOutboundRTPStats(firstConnection);
>+    assert_true(!!stats, "outbound-rtp stats should not be null");
>+    assert_true(Number.isInteger(stats.framesEncoded), "framesEncoded should be an integer");
>+    assert_true(Number.isInteger(stats.qpSum), "outbound qpSum should be an integer");
>+    assert_true(typeof stats.timestamp === "number", "timestamp should be a double");
>+    statsFirstConnection = stats;
>+
>+    stats = await getInboundRTPStats(secondConnection);
>+    assert_true(!!stats, "inbound-rtp stats should not be null");
>+    assert_true(Number.isInteger(stats.framesDecoded), "framesDecoded should be an integer");
>+    assert_true(Number.isInteger(stats.qpSum), "inbound qpSum should be an integer");
>+    assert_true(typeof stats.timestamp === "number", "timestamp should be a double");
>+    statsSecondConnection = stats;
>+
>+    await checkInboundFramesNumberIncreased(secondConnection, statsSecondConnection, 0);
>+    await checkOutboundFramesNumberIncreased(firstConnection, statsFirstConnection, 0);
>+
>+    let types = await getStatsType(firstConnection);
>+    assert_array_equals(types, ["candidate-pair", "certificate", "inbound-rtp", "outbound-rtp", "track"]);
>+
>+    types = await getStatsType(secondConnection);
>+    assert_array_equals(types, ["candidate-pair", "certificate", "inbound-rtp", "outbound-rtp", "track"]);
> }, "Basic video stats");
>+
>+promise_test(async (test) => {
>+    const report = await firstConnection.getSenders()[0].getStats();
>+    checkStatsReportIterator(report);
>+    var instats, outstats;
>+    report.forEach((statItem) => {
>+        if (statItem.type === "outbound-rtp")
>+            outstats = statItem;
>+        else if (statItem.type === "inbound-rtp")
>+            instats = statItem;
>+    });
>+    assert_true(!!outstats);
>+    assert_false(!!instats);
>+}, "Sender stats");
>+
>+promise_test(async (test) => {
>+    const report = await secondConnection.getReceivers()[0].getStats();
>+    checkStatsReportIterator(report);
>+    var instats, outstats;
>+    report.forEach((statItem) => {
>+        if (statItem.type === "outbound-rtp")
>+            outstats = statItem;
>+        else if (statItem.type === "inbound-rtp")
>+            instats = statItem;
>+    });
>+    assert_false(!!outstats);
>+    assert_true(!!instats);
>+}, "Receiver stats");
>         </script>
>     </body>
> </html>

Actions: View | Formatted Diff | Diff

Attachments on bug 189707: 350045 | 350061 | 350064