Adding integration test for unsignaled inbound RTP stream stats.

webrtc/pc/peerconnection_integrationtest.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 88 matching lines @@
 static const int kDefaultSrtpCryptoSuiteGcm = rtc::SRTP_AEAD_AES_256_GCM;
 
 // Helper function for constructing offer/answer options to initiate an ICE
 // restart.
 PeerConnectionInterface::RTCOfferAnswerOptions IceRestartOfferAnswerOptions() {
   PeerConnectionInterface::RTCOfferAnswerOptions options;
   options.ice_restart = true;
   return options;
 }
 
+// Remove all stream information (SSRCs, track IDs, etc.) and "msid-semantic"
+// attribute from received SDP, simulating a legacy endpoint.
+void RemoveSsrcsAndMsids(cricket::SessionDescription* desc) {
+  for (ContentInfo& content : desc->contents()) {
+    MediaContentDescription* media_desc =
+        static_cast<MediaContentDescription*>(content.description);
+    media_desc->mutable_streams().clear();
+  }
+  desc->set_msid_supported(false);
+}
+
 class SignalingMessageReceiver {
  public:
   virtual void ReceiveSdpMessage(const std::string& type,
                                  const std::string& msg) = 0;
   virtual void ReceiveIceMessage(const std::string& sdp_mid,
                                  int sdp_mline_index,
                                  const std::string& msg) = 0;
 
  protected:
   SignalingMessageReceiver() {}
@@ skipping 282 matching lines @@
       }
       for (const auto& renderer : removed_fake_video_renderers_) {
         total += renderer->num_rendered_frames();
       }
     }
     return total;
   }
 
   // Returns a MockStatsObserver in a state after stats gathering finished,
   // which can be used to access the gathered stats.
-  rtc::scoped_refptr<MockStatsObserver> GetStatsForTrack(
+  rtc::scoped_refptr<MockStatsObserver> OldGetStatsForTrack(
       webrtc::MediaStreamTrackInterface* track) {
     rtc::scoped_refptr<MockStatsObserver> observer(
         new rtc::RefCountedObject<MockStatsObserver>());
     EXPECT_TRUE(peer_connection_->GetStats(
         observer, nullptr, PeerConnectionInterface::kStatsOutputLevelStandard));
     EXPECT_TRUE_WAIT(observer->called(), kDefaultTimeout);
     return observer;
   }
 
   // Version that doesn't take a track "filter", and gathers all stats.
-  rtc::scoped_refptr<MockStatsObserver> GetStats() {
-    return GetStatsForTrack(nullptr);
+  rtc::scoped_refptr<MockStatsObserver> OldGetStats() {
+    return OldGetStatsForTrack(nullptr);
+  }
+
+  // Synchronously gets stats and returns them. If it times out, fails the test
+  // and returns null.
+  rtc::scoped_refptr<const webrtc::RTCStatsReport> NewGetStats() {
+    rtc::scoped_refptr<webrtc::MockRTCStatsCollectorCallback> callback(
+        new rtc::RefCountedObject<webrtc::MockRTCStatsCollectorCallback>());
+    peer_connection_->GetStats(callback);
+    EXPECT_TRUE_WAIT(callback->called(), kDefaultTimeout);
+    return callback->report();
   }
 
   int rendered_width() {
     EXPECT_FALSE(fake_video_renderers_.empty());
     return fake_video_renderers_.empty()
                ? 0
                : fake_video_renderers_.begin()->second->width();
   }
 
   int rendered_height() {
@@ skipping 658 matching lines @@
                                                         callee_options));
     rtc::scoped_refptr<webrtc::FakeMetricsObserver> caller_observer =
         new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
     caller()->pc()->RegisterUMAObserver(caller_observer);
     ConnectFakeSignaling();
     caller()->AddAudioVideoMediaStream();
     callee()->AddAudioVideoMediaStream();
     caller()->CreateAndSetAndSignalOffer();
     ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
     EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(expected_cipher_suite),
-                   caller()->GetStats()->SrtpCipher(), kDefaultTimeout);
+                   caller()->OldGetStats()->SrtpCipher(), kDefaultTimeout);
     EXPECT_EQ(
         1, caller_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher,
                                            expected_cipher_suite));
     caller()->pc()->RegisterUMAObserver(nullptr);
   }
 
  private:
   // |ss_| is used by |network_thread_| so it must be destroyed later.
   std::unique_ptr<rtc::PhysicalSocketServer> pss_;
   std::unique_ptr<rtc::VirtualSocketServer> ss_;
@@ skipping 581 matching lines @@
 // is needed to support legacy endpoints.
 // TODO(deadbeef): When we support the MID extension and demuxing on MID, also
 // add a test for an end-to-end test without MID signaling either (basically,
 // the minimum acceptable SDP).
 TEST_F(PeerConnectionIntegrationTest, EndToEndCallWithoutSsrcOrMsidSignaling) {
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
   // Add audio and video, testing that packets can be demuxed on payload type.
   caller()->AddAudioVideoMediaStream();
   callee()->AddAudioVideoMediaStream();
-  // Remove all stream information (SSRCs, track IDs, etc.) and "msid-semantic"
-  // attribute from received SDP, simulating a legacy endpoint.
-  callee()->SetReceivedSdpMunger([](cricket::SessionDescription* desc) {
-    for (ContentInfo& content : desc->contents()) {
-      MediaContentDescription* media_desc =
-          static_cast<MediaContentDescription*>(content.description);
-      media_desc->mutable_streams().clear();
-    }
-    desc->set_msid_supported(false);
-  });
+  // Remove SSRCs and MSIDs from the received offer SDP.
+  callee()->SetReceivedSdpMunger(RemoveSsrcsAndMsids);
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
   ExpectNewFramesReceivedWithWait(
       kDefaultExpectedAudioFrameCount, kDefaultExpectedVideoFrameCount,
       kDefaultExpectedAudioFrameCount, kDefaultExpectedVideoFrameCount,
       kMaxWaitForFramesMs);
 }
 
 // Test that if two video tracks are sent (from caller to callee, in this test),
 // they're transmitted correctly end-to-end.
@@ skipping 56 matching lines @@
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
   ExpectNewFramesReceivedWithWait(
       kDefaultExpectedAudioFrameCount, kDefaultExpectedVideoFrameCount,
       kDefaultExpectedAudioFrameCount, kDefaultExpectedVideoFrameCount,
       kMaxWaitForFramesMs);
 }
 
 // Test that we can receive the audio output level from a remote audio track.
 // TODO(deadbeef): Use a fake audio source and verify that the output level is
 // exactly what the source on the other side was configured with.
-TEST_F(PeerConnectionIntegrationTest, GetAudioOutputLevelStats) {
+TEST_F(PeerConnectionIntegrationTest, GetAudioOutputLevelStatsWithOldStatsApi) {
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
   // Just add an audio track.
   caller()->AddMediaStreamFromTracks(caller()->CreateLocalAudioTrack(),
                                      nullptr);
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
 
   // Get the audio output level stats. Note that the level is not available
   // until an RTCP packet has been received.
-  EXPECT_TRUE_WAIT(callee()->GetStats()->AudioOutputLevel() > 0,
+  EXPECT_TRUE_WAIT(callee()->OldGetStats()->AudioOutputLevel() > 0,
                    kMaxWaitForFramesMs);
 }
 
 // Test that an audio input level is reported.
 // TODO(deadbeef): Use a fake audio source and verify that the input level is
 // exactly what the source was configured with.
-TEST_F(PeerConnectionIntegrationTest, GetAudioInputLevelStats) {
+TEST_F(PeerConnectionIntegrationTest, GetAudioInputLevelStatsWithOldStatsApi) {
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
   // Just add an audio track.
   caller()->AddMediaStreamFromTracks(caller()->CreateLocalAudioTrack(),
                                      nullptr);
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
 
   // Get the audio input level stats. The level should be available very
   // soon after the test starts.
-  EXPECT_TRUE_WAIT(caller()->GetStats()->AudioInputLevel() > 0,
+  EXPECT_TRUE_WAIT(caller()->OldGetStats()->AudioInputLevel() > 0,
                    kMaxWaitForStatsMs);
 }
 
 // Test that we can get incoming byte counts from both audio and video tracks.
-TEST_F(PeerConnectionIntegrationTest, GetBytesReceivedStats) {
+TEST_F(PeerConnectionIntegrationTest, GetBytesReceivedStatsWithOldStatsApi) {
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
   caller()->AddAudioVideoMediaStream();
   // Do offer/answer, wait for the callee to receive some frames.
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
   int expected_caller_received_frames = 0;
   ExpectNewFramesReceivedWithWait(
       expected_caller_received_frames, expected_caller_received_frames,
       kDefaultExpectedAudioFrameCount, kDefaultExpectedVideoFrameCount,
       kMaxWaitForFramesMs);
 
   // Get a handle to the remote tracks created, so they can be used as GetStats
   // filters.
   StreamCollectionInterface* remote_streams = callee()->remote_streams();
   ASSERT_EQ(1u, remote_streams->count());
   ASSERT_EQ(1u, remote_streams->at(0)->GetAudioTracks().size());
   ASSERT_EQ(1u, remote_streams->at(0)->GetVideoTracks().size());
   MediaStreamTrackInterface* remote_audio_track =
       remote_streams->at(0)->GetAudioTracks()[0];
   MediaStreamTrackInterface* remote_video_track =
       remote_streams->at(0)->GetVideoTracks()[0];
 
   // We received frames, so we definitely should have nonzero "received bytes"
   // stats at this point.
-  EXPECT_GT(callee()->GetStatsForTrack(remote_audio_track)->BytesReceived(), 0);
-  EXPECT_GT(callee()->GetStatsForTrack(remote_video_track)->BytesReceived(), 0);
+  EXPECT_GT(callee()->OldGetStatsForTrack(remote_audio_track)->BytesReceived(),
+            0);
+  EXPECT_GT(callee()->OldGetStatsForTrack(remote_video_track)->BytesReceived(),
+            0);
 }
 
 // Test that we can get outgoing byte counts from both audio and video tracks.
-TEST_F(PeerConnectionIntegrationTest, GetBytesSentStats) {
+TEST_F(PeerConnectionIntegrationTest, GetBytesSentStatsWithOldStatsApi) {
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
   auto audio_track = caller()->CreateLocalAudioTrack();
   auto video_track = caller()->CreateLocalVideoTrack();
   caller()->AddMediaStreamFromTracks(audio_track, video_track);
   // Do offer/answer, wait for the callee to receive some frames.
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
   int expected_caller_received_frames = 0;
   ExpectNewFramesReceivedWithWait(
       expected_caller_received_frames, expected_caller_received_frames,
       kDefaultExpectedAudioFrameCount, kDefaultExpectedVideoFrameCount,
       kMaxWaitForFramesMs);
 
   // The callee received frames, so we definitely should have nonzero "sent
   // bytes" stats at this point.
-  EXPECT_GT(caller()->GetStatsForTrack(audio_track)->BytesSent(), 0);
-  EXPECT_GT(caller()->GetStatsForTrack(video_track)->BytesSent(), 0);
+  EXPECT_GT(caller()->OldGetStatsForTrack(audio_track)->BytesSent(), 0);
+  EXPECT_GT(caller()->OldGetStatsForTrack(video_track)->BytesSent(), 0);
+}
+
+// Test that we can get stats (using the new stats implemnetation) for
+// unsignaled streams. Meaning when SSRCs/MSIDs aren't signaled explicitly in
+// SDP.
+TEST_F(PeerConnectionIntegrationTest,
+       GetStatsForUnsignaledStreamWithNewStatsApi) {
+  ASSERT_TRUE(CreatePeerConnectionWrappers());
+  ConnectFakeSignaling();
+  caller()->AddAudioOnlyMediaStream();
+  // Remove SSRCs and MSIDs from the received offer SDP.
+  callee()->SetReceivedSdpMunger(RemoveSsrcsAndMsids);
+  caller()->CreateAndSetAndSignalOffer();
+  ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+  // Wait for one audio frame to be received by the callee.
+  ExpectNewFramesReceivedWithWait(0, 0, 1, 0, kMaxWaitForFramesMs);
+
+  // We received a frame, so we should have nonzero "bytes received" stats for
+  // the unsignaled stream, if stats are working for it.
+  rtc::scoped_refptr<const webrtc::RTCStatsReport> report =
+      callee()->NewGetStats();
+  ASSERT_NE(nullptr, report);
+  auto inbound_stream_stats =
+      report->GetStatsOfType<webrtc::RTCInboundRTPStreamStats>();
+  ASSERT_EQ(1U, inbound_stream_stats.size());
+  ASSERT_TRUE(inbound_stream_stats[0]->bytes_received.is_defined());
+  ASSERT_GT(*inbound_stream_stats[0]->bytes_received, 0U);
+  // TODO(deadbeef): Test that track_id is defined. This is not currently
+  // working since SSRCs are used to match RtpReceivers (and their tracks) with
+  // received stream stats in TrackMediaInfoMap.
 }
 
 // Test that DTLS 1.0 is used if both sides only support DTLS 1.0.
 TEST_F(PeerConnectionIntegrationTest, EndToEndCallWithDtls10) {
   PeerConnectionFactory::Options dtls_10_options;
   dtls_10_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_10;
   ASSERT_TRUE(CreatePeerConnectionWrappersWithOptions(dtls_10_options,
                                                       dtls_10_options));
   ConnectFakeSignaling();
   // Do normal offer/answer and wait for some frames to be received in each
@@ skipping 17 matching lines @@
   ConnectFakeSignaling();
   // Register UMA observer before signaling begins.
   rtc::scoped_refptr<webrtc::FakeMetricsObserver> caller_observer =
       new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
   caller()->pc()->RegisterUMAObserver(caller_observer);
   caller()->AddAudioVideoMediaStream();
   callee()->AddAudioVideoMediaStream();
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
   EXPECT_TRUE_WAIT(rtc::SSLStreamAdapter::IsAcceptableCipher(
-                       caller()->GetStats()->DtlsCipher(), rtc::KT_DEFAULT),
+                       caller()->OldGetStats()->DtlsCipher(), rtc::KT_DEFAULT),
                    kDefaultTimeout);
   EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(kDefaultSrtpCryptoSuite),
-                 caller()->GetStats()->SrtpCipher(), kDefaultTimeout);
+                 caller()->OldGetStats()->SrtpCipher(), kDefaultTimeout);
   EXPECT_EQ(1,
             caller_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher,
                                             kDefaultSrtpCryptoSuite));
 }
 
 // Test getting cipher stats and UMA metrics when DTLS 1.2 is negotiated.
 TEST_F(PeerConnectionIntegrationTest, Dtls12CipherStatsAndUmaMetrics) {
   PeerConnectionFactory::Options dtls_12_options;
   dtls_12_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
   ASSERT_TRUE(CreatePeerConnectionWrappersWithOptions(dtls_12_options,
                                                       dtls_12_options));
   ConnectFakeSignaling();
   // Register UMA observer before signaling begins.
   rtc::scoped_refptr<webrtc::FakeMetricsObserver> caller_observer =
       new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
   caller()->pc()->RegisterUMAObserver(caller_observer);
   caller()->AddAudioVideoMediaStream();
   callee()->AddAudioVideoMediaStream();
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
   EXPECT_TRUE_WAIT(rtc::SSLStreamAdapter::IsAcceptableCipher(
-                       caller()->GetStats()->DtlsCipher(), rtc::KT_DEFAULT),
+                       caller()->OldGetStats()->DtlsCipher(), rtc::KT_DEFAULT),
                    kDefaultTimeout);
   EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(kDefaultSrtpCryptoSuite),
-                 caller()->GetStats()->SrtpCipher(), kDefaultTimeout);
+                 caller()->OldGetStats()->SrtpCipher(), kDefaultTimeout);
   EXPECT_EQ(1,
             caller_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher,
                                             kDefaultSrtpCryptoSuite));
 }
 
 // Test that DTLS 1.0 can be used if the caller supports DTLS 1.2 and the
 // callee only supports 1.0.
 TEST_F(PeerConnectionIntegrationTest, CallerDtls12ToCalleeDtls10) {
   PeerConnectionFactory::Options caller_options;
   caller_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
@@ skipping 808 matching lines @@
       kDefaultExpectedAudioFrameCount, kDefaultExpectedVideoFrameCount,
       kMaxWaitForFramesMs);
 }
 
 TEST_F(PeerConnectionIntegrationTest, GetSources) {
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
   caller()->AddAudioOnlyMediaStream();
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
-  // Wait for one audio frame received by callee.
+  // Wait for one audio frame to be received by the callee.
   ExpectNewFramesReceivedWithWait(0, 0, 1, 0, kMaxWaitForFramesMs);
   ASSERT_GT(callee()->pc()->GetReceivers().size(), 0u);
   auto receiver = callee()->pc()->GetReceivers()[0];
   ASSERT_EQ(receiver->media_type(), cricket::MEDIA_TYPE_AUDIO);
 
   auto contributing_sources = receiver->GetSources();
   ASSERT_GT(receiver->GetParameters().encodings.size(), 0u);
   EXPECT_EQ(receiver->GetParameters().encodings[0].ssrc,
             contributing_sources[0].source_id());
 }
@@ skipping 26 matching lines @@
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
   // Wait for additional audio frames to be received by the callee.
   ExpectNewFramesReceivedWithWait(0, 0, kDefaultExpectedAudioFrameCount, 0,
                                   kMaxWaitForFramesMs);
 }
 
 }  // namespace
 
 #endif  // if !defined(THREAD_SANITIZER)