RTCRtpReceiver.getStats() implemented in content.

This is the content layer wiring of getStats() with the receiver
selector argument. A follow up CL will add blink layer wiring and expose
it in JavaScript.
https://w3c.github.io/webrtc-pc/#dfn-stats-selection-algorithm

(This CL is very similar to the RTCRtpSender.getStats() version:
https://chromium-review.googlesource.com/c/chromium/src/+/973608)

Bug: 680172
Change-Id: I2f0cb0e997602c01ad6b1a2523663811c2e0ebe3
Reviewed-on: https://chromium-review.googlesource.com/975963
Commit-Queue: Henrik Boström <hbos@chromium.org>
Reviewed-by: Taylor Brandstetter <deadbeef@chromium.org>
Cr-Commit-Position: refs/heads/master@{#546760}

content/renderer/media/webrtc/rtc_peer_connection_handler.cc

@@ -2062,6 +2062,7 @@ void RTCPeerConnectionHandler::OnAddRemoteTrack(
           .insert(std::make_pair(
               receiver_id,
               std::make_unique<RTCRtpReceiver>(
+                  native_peer_connection_, task_runner_, signaling_thread(),
                   webrtc_receiver.get(), std::move(remote_track_adapter_ref),
                   std::move(remote_stream_adapter_refs))))
           .first->second;

content/renderer/media/webrtc/rtc_rtp_receiver.cc

@@ -7,6 +7,7 @@
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "content/renderer/media/webrtc/rtc_rtp_contributing_source.h"
+#include "content/renderer/media/webrtc/rtc_stats.h"
 #include "third_party/webrtc/rtc_base/scoped_ref_ptr.h"
 
 namespace content {
@@ -16,12 +17,18 @@ class RTCRtpReceiver::RTCRtpReceiverInternal
           RTCRtpReceiver::RTCRtpReceiverInternal> {
  public:
   RTCRtpReceiverInternal(
+      scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
+      scoped_refptr<base::SingleThreadTaskRunner> main_thread,
+      scoped_refptr<base::SingleThreadTaskRunner> signaling_thread,
       rtc::scoped_refptr<webrtc::RtpReceiverInterface> webrtc_receiver,
       std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef>
           track_adapter,
       std::vector<std::unique_ptr<WebRtcMediaStreamAdapterMap::AdapterRef>>
           stream_adapter_refs)
-      : webrtc_receiver_(std::move(webrtc_receiver)),
+      : native_peer_connection_(std::move(native_peer_connection)),
+        main_thread_(std::move(main_thread)),
+        signaling_thread_(std::move(signaling_thread)),
+        webrtc_receiver_(std::move(webrtc_receiver)),
         track_adapter_(std::move(track_adapter)),
         stream_adapter_refs_(std::move(stream_adapter_refs)) {
     DCHECK(webrtc_receiver_);
@@ -52,6 +59,13 @@ class RTCRtpReceiver::RTCRtpReceiverInternal
     return sources;
   }
 
+  void GetStats(std::unique_ptr<blink::WebRTCStatsReportCallback> callback) {
+    signaling_thread_->PostTask(
+        FROM_HERE,
+        base::BindOnce(&RTCRtpReceiverInternal::GetStatsOnSignalingThread, this,
+                       std::move(callback)));
+  }
+
   webrtc::RtpReceiverInterface* webrtc_receiver() const {
     return webrtc_receiver_.get();
   }
@@ -84,8 +98,17 @@ class RTCRtpReceiver::RTCRtpReceiverInternal
   friend class base::RefCountedThreadSafe<RTCRtpReceiverInternal>;
   ~RTCRtpReceiverInternal() {}
 
-  const rtc::scoped_refptr<webrtc::RtpReceiverInterface> webrtc_receiver_;
+  void GetStatsOnSignalingThread(
+      std::unique_ptr<blink::WebRTCStatsReportCallback> callback) {
+    native_peer_connection_->GetStats(webrtc_receiver_,
+                                      RTCStatsCollectorCallbackImpl::Create(
+                                          main_thread_, std::move(callback)));
+  }
 
+  const scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection_;
+  const scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
+  const scoped_refptr<base::SingleThreadTaskRunner> signaling_thread_;
+  const rtc::scoped_refptr<webrtc::RtpReceiverInterface> webrtc_receiver_;
   // The track adapter is the glue between blink and webrtc layer tracks.
   // Keeping a reference to the adapter ensures it is not disposed, as is
   // required as long as the webrtc layer track is in use by the receiver.
@@ -102,11 +125,17 @@ uintptr_t RTCRtpReceiver::getId(
 }
 
 RTCRtpReceiver::RTCRtpReceiver(
+    scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
+    scoped_refptr<base::SingleThreadTaskRunner> main_thread,
+    scoped_refptr<base::SingleThreadTaskRunner> signaling_thread,
     rtc::scoped_refptr<webrtc::RtpReceiverInterface> webrtc_receiver,
     std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef> track_adapter,
     std::vector<std::unique_ptr<WebRtcMediaStreamAdapterMap::AdapterRef>>
         stream_adapter_refs)
-    : internal_(new RTCRtpReceiverInternal(std::move(webrtc_receiver),
+    : internal_(new RTCRtpReceiverInternal(std::move(native_peer_connection),
+                                           std::move(main_thread),
+                                           std::move(signaling_thread),
+                                           std::move(webrtc_receiver),
                                            std::move(track_adapter),
                                            std::move(stream_adapter_refs))) {}
 
@@ -141,6 +170,11 @@ RTCRtpReceiver::GetSources() {
   return internal_->GetSources();
 }
 
+void RTCRtpReceiver::GetStats(
+    std::unique_ptr<blink::WebRTCStatsReportCallback> callback) {
+  internal_->GetStats(std::move(callback));
+}
+
 webrtc::RtpReceiverInterface* RTCRtpReceiver::webrtc_receiver() const {
   return internal_->webrtc_receiver();
 }

content/renderer/media/webrtc/rtc_rtp_receiver.h

@@ -14,6 +14,7 @@
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebRTCRtpReceiver.h"
 #include "third_party/webrtc/api/mediastreaminterface.h"
+#include "third_party/webrtc/api/peerconnectioninterface.h"
 #include "third_party/webrtc/api/rtpreceiverinterface.h"
 
 namespace content {
@@ -27,6 +28,9 @@ class CONTENT_EXPORT RTCRtpReceiver : public blink::WebRTCRtpReceiver {
       const webrtc::RtpReceiverInterface* webrtc_rtp_receiver);
 
   RTCRtpReceiver(
+      scoped_refptr<webrtc::PeerConnectionInterface> native_peer_connection,
+      scoped_refptr<base::SingleThreadTaskRunner> main_thread,
+      scoped_refptr<base::SingleThreadTaskRunner> signaling_thread,
       rtc::scoped_refptr<webrtc::RtpReceiverInterface> webrtc_receiver,
       std::unique_ptr<WebRtcMediaStreamTrackAdapterMap::AdapterRef>
           track_adapter,
@@ -46,6 +50,7 @@ class CONTENT_EXPORT RTCRtpReceiver : public blink::WebRTCRtpReceiver {
   blink::WebVector<blink::WebMediaStream> Streams() const override;
   blink::WebVector<std::unique_ptr<blink::WebRTCRtpContributingSource>>
   GetSources() override;
+  void GetStats(std::unique_ptr<blink::WebRTCStatsReportCallback>) override;
 
   webrtc::RtpReceiverInterface* webrtc_receiver() const;
   const webrtc::MediaStreamTrackInterface& webrtc_track() const;

content/renderer/media/webrtc/rtc_rtp_receiver_unittest.cc

@@ -14,6 +14,7 @@
 #include "base/synchronization/waitable_event.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
+#include "content/renderer/media/webrtc/mock_peer_connection_impl.h"
 #include "content/renderer/media/webrtc/test/webrtc_stats_report_obtainer.h"
 #include "content/renderer/media/webrtc/webrtc_media_stream_adapter_map.h"
 #include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter_map.h"
@@ -37,6 +38,8 @@ class RTCRtpReceiverTest : public ::testing::Test {
         dependency_factory_.get(), main_thread_,
         new WebRtcMediaStreamTrackAdapterMap(dependency_factory_.get(),
                                              main_thread_));
+    peer_connection_ = new rtc::RefCountedObject<MockPeerConnectionImpl>(
+        dependency_factory_.get(), nullptr);
   }
 
   void TearDown() override { blink::WebHeap::CollectAllGarbageForTesting(); }
@@ -55,11 +58,20 @@ class RTCRtpReceiverTest : public ::testing::Test {
     DCHECK(mock_webrtc_receiver_);
     DCHECK(track_adapter);
     return std::make_unique<RTCRtpReceiver>(
+        peer_connection_.get(), main_thread_,
+        dependency_factory_->GetWebRtcSignalingThread(),
         mock_webrtc_receiver_.get(), std::move(track_adapter),
         std::vector<
             std::unique_ptr<WebRtcMediaStreamAdapterMap::AdapterRef>>());
   }
 
+  scoped_refptr<WebRTCStatsReportObtainer> GetStats() {
+    scoped_refptr<WebRTCStatsReportObtainer> obtainer =
+        new WebRTCStatsReportObtainer();
+    receiver_->GetStats(obtainer->GetStatsCallbackWrapper());
+    return obtainer;
+  }
+
  protected:
   void CreateReceiverOnSignalingThread(
       scoped_refptr<webrtc::MediaStreamTrackInterface> webrtc_track,
@@ -82,6 +94,7 @@ class RTCRtpReceiverTest : public ::testing::Test {
   std::unique_ptr<MockPeerConnectionDependencyFactory> dependency_factory_;
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_;
   scoped_refptr<WebRtcMediaStreamAdapterMap> stream_map_;
+  rtc::scoped_refptr<MockPeerConnectionImpl> peer_connection_;
   rtc::scoped_refptr<webrtc::MockRtpReceiver> mock_webrtc_receiver_;
   std::unique_ptr<RTCRtpReceiver> receiver_;
 };
@@ -114,4 +127,31 @@ TEST_F(RTCRtpReceiverTest, ShallowCopy) {
   EXPECT_EQ(copy->Track().UniqueId(), web_track_unique_id);
 }
 
+TEST_F(RTCRtpReceiverTest, GetStats) {
+  scoped_refptr<MockWebRtcAudioTrack> webrtc_track =
+      MockWebRtcAudioTrack::Create("webrtc_track");
+  receiver_ = CreateReceiver(webrtc_track);
+
+  // Make the mock return a blink version of the |webtc_report|. The mock does
+  // not perform any stats filtering, we just set it to a dummy value.
+  rtc::scoped_refptr<webrtc::RTCStatsReport> webrtc_report =
+      webrtc::RTCStatsReport::Create(0u);
+  webrtc_report->AddStats(
+      std::make_unique<webrtc::RTCInboundRTPStreamStats>("stats-id", 1234u));
+  peer_connection_->SetGetStatsReport(webrtc_report);
+
+  auto obtainer = GetStats();
+  // Make sure the operation is async.
+  EXPECT_FALSE(obtainer->report());
+  // Wait for the report, this performs the necessary run-loop.
+  auto* report = obtainer->WaitForReport();
+  EXPECT_TRUE(report);
+
+  // Verify dummy value.
+  EXPECT_EQ(report->Size(), 1u);
+  auto stats = report->GetStats(blink::WebString::FromUTF8("stats-id"));
+  EXPECT_TRUE(stats);
+  EXPECT_EQ(stats->Timestamp(), 1.234);
+}
+
 }  // namespace content

third_party/WebKit/public/platform/WebRTCRtpReceiver.h

@@ -7,6 +7,7 @@
 
 #include <memory>
 #include "WebCommon.h"
+#include "WebRTCStats.h"
 #include "WebString.h"
 #include "WebVector.h"
 
@@ -31,6 +32,7 @@ class BLINK_PLATFORM_EXPORT WebRTCRtpReceiver {
   virtual WebVector<WebMediaStream> Streams() const = 0;
   virtual WebVector<std::unique_ptr<WebRTCRtpContributingSource>>
   GetSources() = 0;
+  virtual void GetStats(std::unique_ptr<blink::WebRTCStatsReportCallback>) = 0;
 };
 
 }  // namespace blink