RTCIceCandidateStats added.

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.
  */
 
 #include "webrtc/api/rtcstatscollector.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/api/jsepsessiondescription.h"
 #include "webrtc/api/stats/rtcstats_objects.h"
 #include "webrtc/api/stats/rtcstatsreport.h"
 #include "webrtc/api/test/mock_datachannel.h"
 #include "webrtc/api/test/mock_peerconnection.h"
 #include "webrtc/api/test/mock_webrtcsession.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/fakeclock.h"
 #include "webrtc/base/fakesslidentity.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/base/socketaddress.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/base/timedelta.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/media/base/fakemediaengine.h"
+#include "webrtc/p2p/base/port.h"
 
 using testing::_;
 using testing::Invoke;
 using testing::Return;
 using testing::ReturnRef;
 
 namespace webrtc {
 
 namespace {
 
@@ skipping 42 matching lines @@
     for (size_t i = 0; i < chain->GetSize(); i++) {
       fp.reset(rtc::SSLFingerprint::Create("sha-1", &chain->Get(i)));
       EXPECT_TRUE(fp);
       info->fingerprints.push_back(fp->GetRfc4572Fingerprint());
     }
   }
   EXPECT_EQ(info->ders.size(), info->fingerprints.size());
   return info;
 }
 
+std::unique_ptr<cricket::Candidate> CreateFakeCandidate(
+    const std::string& hostname,
+    int port,
+    const std::string& protocol,
+    const std::string& candidate_type,
+    uint32_t priority) {
+  std::unique_ptr<cricket::Candidate> candidate(new cricket::Candidate());
+  candidate->set_address(rtc::SocketAddress(hostname, port));
+  candidate->set_protocol(protocol);
+  candidate->set_type(candidate_type);
+  candidate->set_priority(priority);
+  return candidate;
+}
+
 class RTCStatsCollectorTestHelper : public SetSessionDescriptionObserver {
  public:
   RTCStatsCollectorTestHelper()
       : worker_thread_(rtc::Thread::Current()),
         network_thread_(rtc::Thread::Current()),
         channel_manager_(new cricket::ChannelManager(
             new cricket::FakeMediaEngine(),
             worker_thread_,
             network_thread_)),
         media_controller_(
             MediaControllerInterface::Create(cricket::MediaConfig(),
                                              worker_thread_,
                                              channel_manager_.get())),
         session_(media_controller_.get()),
         pc_() {
     // Default return values for mocks.
     EXPECT_CALL(pc_, session()).WillRepeatedly(Return(&session_));
     EXPECT_CALL(pc_, sctp_data_channels()).WillRepeatedly(
         ReturnRef(data_channels_));
     EXPECT_CALL(session_, GetTransportStats(_)).WillRepeatedly(Return(false));
+    EXPECT_CALL(session_, GetLocalCertificate(_, _)).WillRepeatedly(
+        Return(false));
+    EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
+        .WillRepeatedly(Return(nullptr));
   }
 
   rtc::ScopedFakeClock& fake_clock() { return fake_clock_; }
   MockWebRtcSession& session() { return session_; }
   MockPeerConnection& pc() { return pc_; }
   std::vector<rtc::scoped_refptr<DataChannel>>& data_channels() {
     return data_channels_;
   }
 
   // SetSessionDescriptionObserver overrides.
@@ skipping 177 matching lines @@
           &test_->pc(), 50 * rtc::kNumMicrosecsPerMillisec)) {
   }
 
   rtc::scoped_refptr<const RTCStatsReport> GetStatsReport() {
     rtc::scoped_refptr<StatsCallback> callback = StatsCallback::Create();
     collector_->GetStatsReport(callback);
     EXPECT_TRUE_WAIT(callback->report(), kGetStatsReportTimeoutMs);
     return callback->report();
   }
 
+  void ExpectReportContainsCandidate(
+      const rtc::scoped_refptr<const RTCStatsReport>& report,
+      const cricket::Candidate& candidate,
+      bool is_local) {
+    const RTCStats* stats =
+        report->Get("RTCIceCandidate_" + candidate.id());
+    EXPECT_TRUE(stats);
+    const RTCIceCandidateStats* candidate_stats;
+    if (is_local)
+        candidate_stats = &stats->cast_to<RTCLocalIceCandidateStats>();
+    else
+        candidate_stats = &stats->cast_to<RTCRemoteIceCandidateStats>();
+    EXPECT_EQ(*candidate_stats->ip, candidate.address().ipaddr().ToString());
+    EXPECT_EQ(*candidate_stats->port,
+              static_cast<int32_t>(candidate.address().port()));
+    EXPECT_EQ(*candidate_stats->protocol, candidate.protocol());
+    EXPECT_EQ(*candidate_stats->candidate_type,
+              CandidateTypeToRTCIceCandidateType(candidate.type()));
+    EXPECT_EQ(*candidate_stats->priority,
+              static_cast<int32_t>(candidate.priority()));
+    // TODO(hbos): Define candidate_stats->url. crbug.com/632723
+    EXPECT_FALSE(candidate_stats->url.is_defined());
+  }
+
   void ExpectReportContainsCertificateInfo(
       const rtc::scoped_refptr<const RTCStatsReport>& report,
       const CertificateInfo& cert_info) {
     for (size_t i = 0; i < cert_info.fingerprints.size(); ++i) {
       const RTCStats* stats = report->Get(
           "RTCCertificate_" + cert_info.fingerprints[i]);
       EXPECT_TRUE(stats);
       const RTCCertificateStats& cert_stats =
           stats->cast_to<const RTCCertificateStats>();
       EXPECT_EQ(*cert_stats.fingerprint, cert_info.fingerprints[i]);
@@ skipping 206 matching lines @@
         if (transport_name == "transport")
           return remote_certinfo->certificate->ssl_certificate().GetReference();
         return static_cast<rtc::SSLCertificate*>(nullptr);
       }));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
   ExpectReportContainsCertificateInfo(report, *local_certinfo.get());
   ExpectReportContainsCertificateInfo(report, *remote_certinfo.get());
 }
 
+TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidateStats) {
+  // Candidates in the first transport stats.
+  std::unique_ptr<cricket::Candidate> a_local_host = CreateFakeCandidate(
+      "1.2.3.4", 5,
+      "a_local_host's protocol",
+      cricket::LOCAL_PORT_TYPE,
+      0);
+  std::unique_ptr<cricket::Candidate> a_remote_srflx = CreateFakeCandidate(
+      "6.7.8.9", 10,
+      "remote_srflx's protocol",
+      cricket::STUN_PORT_TYPE,
+      1);
+  std::unique_ptr<cricket::Candidate> a_local_prflx = CreateFakeCandidate(
+      "11.12.13.14", 15,
+      "a_local_prflx's protocol",
+      cricket::PRFLX_PORT_TYPE,
+      2);
+  std::unique_ptr<cricket::Candidate> a_remote_relay = CreateFakeCandidate(
+      "16.17.18.19", 20,
+      "a_remote_relay's protocol",
+      cricket::RELAY_PORT_TYPE,
+      3);
+  // Candidates in the second transport stats.
+  std::unique_ptr<cricket::Candidate> b_local = CreateFakeCandidate(
+      "42.42.42.42", 42,
+      "b_local's protocol",
+      cricket::LOCAL_PORT_TYPE,
+      42);
+  std::unique_ptr<cricket::Candidate> b_remote = CreateFakeCandidate(
+      "42.42.42.42", 42,
+      "b_remote's protocol",
+      cricket::LOCAL_PORT_TYPE,
+      42);
+
+  SessionStats session_stats;
+
+  cricket::TransportChannelStats a_transport_channel_stats;
+  a_transport_channel_stats.connection_infos.push_back(
+      cricket::ConnectionInfo());
+  a_transport_channel_stats.connection_infos[0].local_candidate =
+      *a_local_host.get();
+  a_transport_channel_stats.connection_infos[0].remote_candidate =
+      *a_remote_srflx.get();
+  a_transport_channel_stats.connection_infos.push_back(
+      cricket::ConnectionInfo());
+  a_transport_channel_stats.connection_infos[1].local_candidate =
+      *a_local_prflx.get();
+  a_transport_channel_stats.connection_infos[1].remote_candidate =
+      *a_remote_relay.get();
+  session_stats.transport_stats["a"].channel_stats.push_back(
+      a_transport_channel_stats);
+
+  cricket::TransportChannelStats b_transport_channel_stats;
+  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;
+      }));
+
+  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);
+}
+
 TEST_F(RTCStatsCollectorTest, CollectRTCPeerConnectionStats) {
   int64_t before = rtc::TimeUTCMicros();
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
   int64_t after = rtc::TimeUTCMicros();
   EXPECT_EQ(report->GetStatsOfType<RTCPeerConnectionStats>().size(),
             static_cast<size_t>(1)) << "Expecting 1 RTCPeerConnectionStats.";
   const RTCStats* stats = report->Get("RTCPeerConnection");
   EXPECT_TRUE(stats);
   EXPECT_LE(before, stats->timestamp_us());
   EXPECT_LE(stats->timestamp_us(), after);
@@ skipping 46 matching lines @@
   rtc::scoped_refptr<FakeRTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
   collector_->VerifyThreadUsageAndResultsMerging();
 }
 
 }  // namespace
 
 }  // namespace webrtc