RTCStatsCollector: Utilize network thread to minimize thread hops.

webrtc/api/rtcstatscollector_unittest.cc

 /*
  *  Copyright 2016 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 293 matching lines @@
         session_(media_controller_.get()),
         pc_() {
     // Default return values for mocks.
     EXPECT_CALL(pc_, local_streams()).WillRepeatedly(Return(nullptr));
     EXPECT_CALL(pc_, remote_streams()).WillRepeatedly(Return(nullptr));
     EXPECT_CALL(pc_, session()).WillRepeatedly(Return(&session_));
     EXPECT_CALL(pc_, sctp_data_channels()).WillRepeatedly(
         ReturnRef(data_channels_));
     EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
     EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
-    EXPECT_CALL(session_, GetTransportStats(_)).WillRepeatedly(Return(false));
+    EXPECT_CALL(session_, GetSessionStats(_)).WillRepeatedly(ReturnNull());
     EXPECT_CALL(session_, GetLocalCertificate(_, _)).WillRepeatedly(
         Return(false));
     EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
         .WillRepeatedly(Return(nullptr));
   }
 
   rtc::ScopedFakeClock& fake_clock() { return fake_clock_; }
   rtc::Thread* worker_thread() { return worker_thread_; }
   rtc::Thread* network_thread() { return network_thread_; }
   cricket::FakeMediaEngine* media_engine() { return media_engine_; }
@@ skipping 294 matching lines @@
 
 TEST_F(RTCStatsCollectorTest, CollectRTCCertificateStatsSingle) {
   std::unique_ptr<CertificateInfo> local_certinfo =
       CreateFakeCertificateAndInfoFromDers(
           std::vector<std::string>({ "(local) single certificate" }));
   std::unique_ptr<CertificateInfo> remote_certinfo =
       CreateFakeCertificateAndInfoFromDers(
           std::vector<std::string>({ "(remote) single certificate" }));
 
   // Mock the session to return the local and remote certificates.
-  EXPECT_CALL(test_->session(), GetTransportStats(_)).WillRepeatedly(Invoke(
-      [this](SessionStats* stats) {
+  EXPECT_CALL(test_->session(), GetSessionStats(_)).WillRepeatedly(Invoke(
+      [this](const ChannelNamePairs&) {
+        std::unique_ptr<SessionStats> stats(new SessionStats());
         stats->transport_stats["transport"].transport_name = "transport";
-        return true;
+        return stats;
       }));
   EXPECT_CALL(test_->session(), GetLocalCertificate(_, _)).WillRepeatedly(
       Invoke([this, &local_certinfo](const std::string& transport_name,
              rtc::scoped_refptr<rtc::RTCCertificate>* certificate) {
         if (transport_name == "transport") {
           *certificate = local_certinfo->certificate;
           return true;
         }
         return false;
       }));
@@ skipping 60 matching lines @@
 
   EXPECT_CALL(*video_media_channel, GetStats(_))
       .WillOnce(DoAll(SetArgPointee<0>(video_media_info), Return(true)));
 
   SessionStats session_stats;
   session_stats.proxy_to_transport["VoiceContentName"] = "TransportName";
   session_stats.proxy_to_transport["VideoContentName"] = "TransportName";
   session_stats.transport_stats["TransportName"].transport_name =
       "TransportName";
 
-  EXPECT_CALL(test_->session(), GetTransportStats(_))
-      .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats), Return(true)));
+  EXPECT_CALL(test_->session(), GetSessionStats(_)).WillRepeatedly(Invoke(
+      [&session_stats](const ChannelNamePairs&) {
+        return std::unique_ptr<SessionStats>(new SessionStats(session_stats));
+      }));
   EXPECT_CALL(test_->session(), voice_channel())
       .WillRepeatedly(Return(&voice_channel));
   EXPECT_CALL(test_->session(), video_channel())
       .WillRepeatedly(Return(&video_channel));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
 
   RTCCodecStats expected_inbound_audio_codec(
       "RTCCodec_InboundAudio_1", report->timestamp_us());
   expected_inbound_audio_codec.payload_type = 1;
@@ skipping 56 matching lines @@
           std::vector<std::string>({ "(local) video" }));
   video_local_certinfo = CreateFakeCertificateAndInfoFromDers(
       video_local_certinfo->ders);
   std::unique_ptr<CertificateInfo> video_remote_certinfo =
       CreateFakeCertificateAndInfoFromDers(
           std::vector<std::string>({ "(remote) video" }));
   video_remote_certinfo = CreateFakeCertificateAndInfoFromDers(
       video_remote_certinfo->ders);
 
   // Mock the session to return the local and remote certificates.
-  EXPECT_CALL(test_->session(), GetTransportStats(_)).WillRepeatedly(Invoke(
-      [this](SessionStats* stats) {
+  EXPECT_CALL(test_->session(), GetSessionStats(_)).WillRepeatedly(Invoke(
+      [this](const ChannelNamePairs&) {
+        std::unique_ptr<SessionStats> stats(new SessionStats());
         stats->transport_stats["audio"].transport_name = "audio";
         stats->transport_stats["video"].transport_name = "video";
-        return true;
+        return stats;
       }));
   EXPECT_CALL(test_->session(), GetLocalCertificate(_, _)).WillRepeatedly(
       Invoke([this, &audio_local_certinfo, &video_local_certinfo](
             const std::string& transport_name,
             rtc::scoped_refptr<rtc::RTCCertificate>* certificate) {
         if (transport_name == "audio") {
           *certificate = audio_local_certinfo->certificate;
           return true;
         }
         if (transport_name == "video") {
@@ skipping 34 matching lines @@
       CreateFakeCertificateAndInfoFromDers(local_ders);
   std::vector<std::string> remote_ders;
   remote_ders.push_back("(remote) this");
   remote_ders.push_back("(remote) is");
   remote_ders.push_back("(remote) another");
   remote_ders.push_back("(remote) chain");
   std::unique_ptr<CertificateInfo> remote_certinfo =
       CreateFakeCertificateAndInfoFromDers(remote_ders);
 
   // Mock the session to return the local and remote certificates.
-  EXPECT_CALL(test_->session(), GetTransportStats(_)).WillRepeatedly(Invoke(
-      [this](SessionStats* stats) {
+  EXPECT_CALL(test_->session(), GetSessionStats(_)).WillRepeatedly(Invoke(
+      [this](const ChannelNamePairs&) {
+        std::unique_ptr<SessionStats> stats(new SessionStats());
         stats->transport_stats["transport"].transport_name = "transport";
-        return true;
+        return stats;
       }));
   EXPECT_CALL(test_->session(), GetLocalCertificate(_, _)).WillRepeatedly(
       Invoke([this, &local_certinfo](const std::string& transport_name,
              rtc::scoped_refptr<rtc::RTCCertificate>* certificate) {
         if (transport_name == "transport") {
           *certificate = local_certinfo->certificate;
           return true;
         }
         return false;
       }));
@@ skipping 104 matching lines @@
   b_transport_channel_stats.connection_infos.push_back(
       cricket::ConnectionInfo());
   b_transport_channel_stats.connection_infos[0].local_candidate =
       *b_local.get();
   b_transport_channel_stats.connection_infos[0].remote_candidate =
       *b_remote.get();
   session_stats.transport_stats["b"].channel_stats.push_back(
       b_transport_channel_stats);
 
   // Mock the session to return the desired candidates.
-  EXPECT_CALL(test_->session(), GetTransportStats(_)).WillRepeatedly(Invoke(
-      [this, &session_stats](SessionStats* stats) {
-        *stats = session_stats;
-        return true;
+  EXPECT_CALL(test_->session(), GetSessionStats(_)).WillRepeatedly(Invoke(
+      [&session_stats](const ChannelNamePairs&) {
+        return std::unique_ptr<SessionStats>(new SessionStats(session_stats));
       }));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
   ExpectReportContainsCandidate(report, *a_local_host.get(), true);
   ExpectReportContainsCandidate(report, *a_remote_srflx.get(), false);
   ExpectReportContainsCandidate(report, *a_local_prflx.get(), true);
   ExpectReportContainsCandidate(report, *a_remote_relay.get(), false);
   ExpectReportContainsCandidate(report, *b_local.get(), true);
   ExpectReportContainsCandidate(report, *b_remote.get(), false);
 }
@@ skipping 20 matching lines @@
   connection_info.sent_ping_responses = 1000;
 
   cricket::TransportChannelStats transport_channel_stats;
   transport_channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
   transport_channel_stats.connection_infos.push_back(connection_info);
   session_stats.transport_stats["transport"].transport_name = "transport";
   session_stats.transport_stats["transport"].channel_stats.push_back(
       transport_channel_stats);
 
   // Mock the session to return the desired candidates.
-  EXPECT_CALL(test_->session(), GetTransportStats(_)).WillRepeatedly(Invoke(
-      [this, &session_stats](SessionStats* stats) {
-        *stats = session_stats;
-        return true;
+  EXPECT_CALL(test_->session(), GetSessionStats(_)).WillRepeatedly(Invoke(
+      [&session_stats](const ChannelNamePairs&) {
+        return std::unique_ptr<SessionStats>(new SessionStats(session_stats));
       }));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
 
   RTCIceCandidatePairStats expected_pair("RTCIceCandidatePair_" +
                                              local_candidate->id() + "_" +
                                              remote_candidate->id(),
                                          report->timestamp_us());
   expected_pair.transport_id =
       "RTCTransport_transport_" +
@@ skipping 300 matching lines @@
   session_stats.proxy_to_transport["VoiceContentName"] = "TransportName";
   session_stats.transport_stats["TransportName"].transport_name =
       "TransportName";
 
   // Make sure the associated |RTCTransportStats| is created.
   cricket::TransportChannelStats channel_stats;
   channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
   session_stats.transport_stats["TransportName"].channel_stats.push_back(
       channel_stats);
 
-  EXPECT_CALL(test_->session(), GetTransportStats(_))
-      .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats), Return(true)));
+  EXPECT_CALL(test_->session(), GetSessionStats(_)).WillRepeatedly(Invoke(
+      [&session_stats](const ChannelNamePairs&) {
+        return std::unique_ptr<SessionStats>(new SessionStats(session_stats));
+      }));
   EXPECT_CALL(test_->session(), voice_channel())
       .WillRepeatedly(Return(&voice_channel));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
 
   RTCInboundRTPStreamStats expected_audio(
       "RTCInboundRTPAudioStream_1", report->timestamp_us());
   expected_audio.ssrc = "1";
   expected_audio.is_remote = false;
   expected_audio.media_type = "audio";
@@ skipping 50 matching lines @@
   session_stats.proxy_to_transport["VideoContentName"] = "TransportName";
   session_stats.transport_stats["TransportName"].transport_name =
       "TransportName";
 
   // Make sure the associated |RTCTransportStats| is created.
   cricket::TransportChannelStats channel_stats;
   channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
   session_stats.transport_stats["TransportName"].channel_stats.push_back(
       channel_stats);
 
-  EXPECT_CALL(test_->session(), GetTransportStats(_))
-      .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats), Return(true)));
+  EXPECT_CALL(test_->session(), GetSessionStats(_)).WillRepeatedly(Invoke(
+      [&session_stats](const ChannelNamePairs&) {
+        return std::unique_ptr<SessionStats>(new SessionStats(session_stats));
+      }));
   EXPECT_CALL(test_->session(), video_channel())
       .WillRepeatedly(Return(&video_channel));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
 
   RTCInboundRTPStreamStats expected_video(
       "RTCInboundRTPVideoStream_1", report->timestamp_us());
   expected_video.ssrc = "1";
   expected_video.is_remote = false;
   expected_video.media_type = "video";
@@ skipping 47 matching lines @@
   session_stats.proxy_to_transport["VoiceContentName"] = "TransportName";
   session_stats.transport_stats["TransportName"].transport_name =
       "TransportName";
 
   // Make sure the associated |RTCTransportStats| is created.
   cricket::TransportChannelStats channel_stats;
   channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
   session_stats.transport_stats["TransportName"].channel_stats.push_back(
       channel_stats);
 
-  EXPECT_CALL(test_->session(), GetTransportStats(_))
-      .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats), Return(true)));
+  EXPECT_CALL(test_->session(), GetSessionStats(_)).WillRepeatedly(Invoke(
+      [&session_stats](const ChannelNamePairs&) {
+        return std::unique_ptr<SessionStats>(new SessionStats(session_stats));
+      }));
   EXPECT_CALL(test_->session(), voice_channel())
       .WillRepeatedly(Return(&voice_channel));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
 
   RTCOutboundRTPStreamStats expected_audio(
       "RTCOutboundRTPAudioStream_1", report->timestamp_us());
   expected_audio.ssrc = "1";
   expected_audio.is_remote = false;
   expected_audio.media_type = "audio";
@@ skipping 46 matching lines @@
   session_stats.proxy_to_transport["VideoContentName"] = "TransportName";
   session_stats.transport_stats["TransportName"].transport_name =
       "TransportName";
 
   // Make sure the associated |RTCTransportStats| is created.
   cricket::TransportChannelStats channel_stats;
   channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
   session_stats.transport_stats["TransportName"].channel_stats.push_back(
       channel_stats);
 
-  EXPECT_CALL(test_->session(), GetTransportStats(_))
-      .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats), Return(true)));
+  EXPECT_CALL(test_->session(), GetSessionStats(_)).WillRepeatedly(Invoke(
+      [&session_stats](const ChannelNamePairs&) {
+        return std::unique_ptr<SessionStats>(new SessionStats(session_stats));
+      }));
   EXPECT_CALL(test_->session(), video_channel())
       .WillRepeatedly(Return(&video_channel));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
 
   RTCOutboundRTPStreamStats expected_video(
       "RTCOutboundRTPVideoStream_1", report->timestamp_us());
   expected_video.ssrc = "1";
   expected_video.is_remote = false;
   expected_video.media_type = "video";
@@ skipping 39 matching lines @@
   rtp_connection_info.sent_total_bytes = 42;
   rtp_connection_info.recv_total_bytes = 1337;
   cricket::TransportChannelStats rtp_transport_channel_stats;
   rtp_transport_channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
   rtp_transport_channel_stats.connection_infos.push_back(rtp_connection_info);
   session_stats.transport_stats["transport"].channel_stats.push_back(
       rtp_transport_channel_stats);
 
 
   // Mock the session to return the desired candidates.
-  EXPECT_CALL(test_->session(), GetTransportStats(_)).WillRepeatedly(Invoke(
-      [this, &session_stats](SessionStats* stats) {
-        *stats = session_stats;
-        return true;
+  EXPECT_CALL(test_->session(), GetSessionStats(_)).WillRepeatedly(Invoke(
+      [&session_stats](const ChannelNamePairs&) {
+        return std::unique_ptr<SessionStats>(new SessionStats(session_stats));
       }));
 
   // Get stats without RTCP, an active connection or certificates.
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
 
   RTCTransportStats expected_rtp_transport(
       "RTCTransport_transport_" +
           rtc::ToString<>(cricket::ICE_CANDIDATE_COMPONENT_RTP),
       report->timestamp_us());
   expected_rtp_transport.bytes_sent = 42;
@@ skipping 124 matching lines @@
   rtc::scoped_refptr<FakeRTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
   collector_->VerifyThreadUsageAndResultsMerging();
 }
 
 }  // namespace
 
 }  // namespace webrtc