TransportController refactoring.

talk/app/webrtc/statscollector_unittest.cc

 /*
  * libjingle
  * Copyright 2014 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
  *     this list of conditions and the following disclaimer in the documentation
  *     and/or other materials provided with the distribution.
  *  3. The name of the author may not be used to endorse or promote products
  *     derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include <stdio.h>
 
+#include <algorithm>
+
 #include "talk/app/webrtc/statscollector.h"
 
 #include "talk/app/webrtc/mediastream.h"
 #include "talk/app/webrtc/mediastreaminterface.h"
 #include "talk/app/webrtc/mediastreamsignaling.h"
 #include "talk/app/webrtc/mediastreamtrack.h"
 #include "talk/app/webrtc/test/fakedatachannelprovider.h"
 #include "talk/app/webrtc/test/fakemediastreamsignaling.h"
 #include "talk/app/webrtc/videotrack.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/devices/fakedevicemanager.h"
 #include "talk/session/media/channelmanager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/base64.h"
 #include "webrtc/base/fakesslidentity.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/network.h"
-#include "webrtc/p2p/base/fakesession.h"
+#include "webrtc/p2p/base/faketransportcontroller.h"
 
 using rtc::scoped_ptr;
 using testing::_;
 using testing::DoAll;
 using testing::Field;
 using testing::Return;
 using testing::ReturnNull;
 using testing::SetArgPointee;
 using webrtc::PeerConnectionInterface;
 using webrtc::StatsReport;
@@ skipping 23 matching lines @@
                     rtc::Thread::Current(), NULL, NULL) {
   }
   MOCK_METHOD0(voice_channel, cricket::VoiceChannel*());
   MOCK_METHOD0(video_channel, cricket::VideoChannel*());
   MOCK_CONST_METHOD0(mediastream_signaling, const MediaStreamSignaling*());
   // Libjingle uses "local" for a outgoing track, and "remote" for a incoming
   // track.
   MOCK_METHOD2(GetLocalTrackIdBySsrc, bool(uint32, std::string*));
   MOCK_METHOD2(GetRemoteTrackIdBySsrc, bool(uint32, std::string*));
   MOCK_METHOD1(GetTransportStats, bool(cricket::SessionStats*));
-  MOCK_METHOD1(GetTransport, cricket::Transport*(const std::string&));
+  MOCK_METHOD2(GetLocalCertificate,
+               bool(const std::string& transport_name,
+                    rtc::scoped_refptr<rtc::RTCCertificate>* certificate));
+  MOCK_METHOD2(GetRemoteSSLCertificate,
+               bool(const std::string& transport_name,
+                    rtc::SSLCertificate** cert));
 };
 
 class MockVideoMediaChannel : public cricket::FakeVideoMediaChannel {
  public:
   MockVideoMediaChannel() :
       cricket::FakeVideoMediaChannel(NULL, cricket::VideoOptions()) {}
   MOCK_METHOD1(GetStats, bool(cricket::VideoMediaInfo*));
 };
 
 class MockVoiceMediaChannel : public cricket::FakeVoiceMediaChannel {
@@ skipping 390 matching lines @@
   ~StatsCollectorTest() {}
 
   // This creates a standard setup with a transport called "trspname"
   // having one transport channel
   // and the specified virtual connection name.
   void InitSessionStats(const std::string& vc_name) {
     const std::string kTransportName("trspname");
     cricket::TransportStats transport_stats;
     cricket::TransportChannelStats channel_stats;
     channel_stats.component = 1;
-    transport_stats.content_name = kTransportName;
+    transport_stats.transport_name = kTransportName;
     transport_stats.channel_stats.push_back(channel_stats);
 
     session_stats_.transport_stats[kTransportName] = transport_stats;
     session_stats_.proxy_to_transport[vc_name] = kTransportName;
   }
 
   // Adds a outgoing video track with a given SSRC into the stats.
   void AddOutgoingVideoTrackStats() {
     stream_ = webrtc::MediaStream::Create("streamlabel");
     track_= webrtc::VideoTrack::Create(kLocalTrackId, NULL);
@@ skipping 126 matching lines @@
 
     StatsReports reports;  // returned values.
 
     // Fake stats to process.
     cricket::TransportChannelStats channel_stats;
     channel_stats.component = 1;
     channel_stats.srtp_cipher = "the-srtp-cipher";
     channel_stats.ssl_cipher = "the-ssl-cipher";
 
     cricket::TransportStats transport_stats;
-    transport_stats.content_name = "audio";
+    transport_stats.transport_name = "audio";
     transport_stats.channel_stats.push_back(channel_stats);
 
     cricket::SessionStats session_stats;
-    session_stats.transport_stats[transport_stats.content_name] =
+    session_stats.transport_stats[transport_stats.transport_name] =
         transport_stats;
 
-    // Fake certificates to report.
+    // Fake certificate to report
     rtc::scoped_refptr<rtc::RTCCertificate> local_certificate(
         rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::FakeSSLIdentity>(
-            new rtc::FakeSSLIdentity(local_cert)).Pass()));
-    rtc::scoped_ptr<rtc::FakeSSLCertificate> remote_cert_copy(
-        remote_cert.GetReference());
-
-    // Fake transport object.
-    rtc::scoped_ptr<cricket::FakeTransport> transport(
-        new cricket::FakeTransport(
-            session_.signaling_thread(),
-            session_.worker_thread(),
-            transport_stats.content_name));
-    transport->SetCertificate(local_certificate);
-    cricket::FakeTransportChannel* channel =
-        static_cast<cricket::FakeTransportChannel*>(
-            transport->CreateChannel(channel_stats.component));
-    EXPECT_FALSE(channel == NULL);
-    channel->SetRemoteSSLCertificate(remote_cert_copy.get());
+                                        new rtc::FakeSSLIdentity(local_cert))
+                                        .Pass()));
 
     // Configure MockWebRtcSession
-    EXPECT_CALL(session_, GetTransport(transport_stats.content_name))
-      .WillRepeatedly(Return(transport.get()));
+    EXPECT_CALL(session_,
+                GetLocalCertificate(transport_stats.transport_name, _))
+        .WillOnce(DoAll(SetArgPointee<1>(local_certificate), Return(true)));
+    EXPECT_CALL(session_,
+                GetRemoteSSLCertificate(transport_stats.transport_name, _))
+        .WillOnce(
+            DoAll(SetArgPointee<1>(remote_cert.GetReference()), Return(true)));
     EXPECT_CALL(session_, GetTransportStats(_))
       .WillOnce(DoAll(SetArgPointee<0>(session_stats),
                       Return(true)));
     EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
     EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
 
     stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
 
     stats.GetStats(NULL, &reports);
 
@@ skipping 93 matching lines @@
                                      StatsReport::kStatsValueNameState));
   EXPECT_EQ("", ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel,
                                   reports,
                                   StatsReport::kStatsValueNameProtocol));
 }
 
 // This test verifies that 64-bit counters are passed successfully.
 TEST_F(StatsCollectorTest, BytesCounterHandles64Bits) {
   StatsCollectorForTest stats(&session_);
 
+  EXPECT_CALL(session_, GetLocalCertificate(_, _))
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
+      .WillRepeatedly(Return(false));
+
   const char kVideoChannelName[] = "video";
 
   InitSessionStats(kVideoChannelName);
   EXPECT_CALL(session_, GetTransportStats(_))
       .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
                             Return(true)));
-  EXPECT_CALL(session_, GetTransport(_))
-      .WillRepeatedly(Return(static_cast<cricket::Transport*>(NULL)));
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_channel, NULL, kVideoChannelName, false);
   StatsReports reports;  // returned values.
   cricket::VideoSenderInfo video_sender_info;
   cricket::VideoMediaInfo stats_read;
   // The number of bytes must be larger than 0xFFFFFFFF for this test.
   const int64 kBytesSent = 12345678901234LL;
   const std::string kBytesSentString("12345678901234");
@@ skipping 15 matching lines @@
   stats.GetStats(NULL, &reports);
   std::string result = ExtractSsrcStatsValue(reports,
       StatsReport::kStatsValueNameBytesSent);
   EXPECT_EQ(kBytesSentString, result);
 }
 
 // Test that BWE information is reported via stats.
 TEST_F(StatsCollectorTest, BandwidthEstimationInfoIsReported) {
   StatsCollectorForTest stats(&session_);
 
+  EXPECT_CALL(session_, GetLocalCertificate(_, _))
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
+      .WillRepeatedly(Return(false));
+
   const char kVideoChannelName[] = "video";
 
   InitSessionStats(kVideoChannelName);
   EXPECT_CALL(session_, GetTransportStats(_))
       .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
                             Return(true)));
-  EXPECT_CALL(session_, GetTransport(_))
-      .WillRepeatedly(Return(static_cast<cricket::Transport*>(NULL)));
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_channel, NULL, kVideoChannelName, false);
 
   StatsReports reports;  // returned values.
   cricket::VideoSenderInfo video_sender_info;
   cricket::VideoMediaInfo stats_read;
   // Set up an SSRC just to test that we get both kinds of stats back: SSRC and
   // BWE.
@@ skipping 85 matching lines @@
                         reports,
                         StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kLocalTrackId, trackValue);
 }
 
 // This test verifies that the empty track report exists in the returned stats
 // when StatsCollector::UpdateStats is called with ssrc stats.
 TEST_F(StatsCollectorTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
   StatsCollectorForTest stats(&session_);
 
+  EXPECT_CALL(session_, GetLocalCertificate(_, _))
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
+      .WillRepeatedly(Return(false));
+
   const char kVideoChannelName[] = "video";
   InitSessionStats(kVideoChannelName);
   EXPECT_CALL(session_, GetTransportStats(_))
       .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
                             Return(true)));
-  EXPECT_CALL(session_, GetTransport(_))
-      .WillRepeatedly(Return(static_cast<cricket::Transport*>(NULL)));
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_channel, NULL, kVideoChannelName, false);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
 
   // Constructs an ssrc stats update.
   cricket::VideoSenderInfo video_sender_info;
   cricket::VideoMediaInfo stats_read;
@@ skipping 38 matching lines @@
   std::string track_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kLocalTrackId, track_id);
 }
 
 // This test verifies that an SSRC object has the identifier of a Transport
 // stats object, and that this transport stats object exists in stats.
 TEST_F(StatsCollectorTest, TransportObjectLinkedFromSsrcObject) {
   StatsCollectorForTest stats(&session_);
 
-  // Ignore unused callback (logspam).
-  EXPECT_CALL(session_, GetTransport(_))
-      .WillRepeatedly(Return(static_cast<cricket::Transport*>(NULL)));
+  EXPECT_CALL(session_, GetLocalCertificate(_, _))
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
+      .WillRepeatedly(Return(false));
+
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
-  // The content_name known by the video channel.
+  // The transport_name known by the video channel.
   const std::string kVcName("vcname");
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_channel, NULL, kVcName, false);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
 
   // Constructs an ssrc stats update.
   cricket::VideoSenderInfo video_sender_info;
   cricket::VideoMediaInfo stats_read;
   const int64 kBytesSent = 12345678901234LL;
@@ skipping 37 matching lines @@
   const StatsReport* transport_report = FindReportById(reports, id);
   ASSERT_FALSE(transport_report == NULL);
 }
 
 // This test verifies that a remote stats object will not be created for
 // an outgoing SSRC where remote stats are not returned.
 TEST_F(StatsCollectorTest, RemoteSsrcInfoIsAbsent) {
   StatsCollectorForTest stats(&session_);
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
-  // The content_name known by the video channel.
+  // The transport_name known by the video channel.
   const std::string kVcName("vcname");
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_channel, NULL, kVcName, false);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
 
   EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
   EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   StatsReports reports;
   stats.GetStats(NULL, &reports);
   const StatsReport* remote_report = FindNthReportByType(reports,
       StatsReport::kStatsReportTypeRemoteSsrc, 1);
   EXPECT_TRUE(remote_report == NULL);
 }
 
 // This test verifies that a remote stats object will be created for
 // an outgoing SSRC where stats are returned.
 TEST_F(StatsCollectorTest, RemoteSsrcInfoIsPresent) {
   StatsCollectorForTest stats(&session_);
 
-  // Ignore unused callback (logspam).
-  EXPECT_CALL(session_, GetTransport(_))
-      .WillRepeatedly(Return(static_cast<cricket::Transport*>(NULL)));
+  EXPECT_CALL(session_, GetLocalCertificate(_, _))
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
+      .WillRepeatedly(Return(false));
+
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
-  // The content_name known by the video channel.
+  // The transport_name known by the video channel.
   const std::string kVcName("vcname");
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_channel, NULL, kVcName, false);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
 
   // Instruct the session to return stats containing the transport channel.
   InitSessionStats(kVcName);
   EXPECT_CALL(session_, GetTransportStats(_))
       .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
@@ skipping 24 matching lines @@
       StatsReport::kStatsReportTypeRemoteSsrc, 1);
   EXPECT_FALSE(remote_report == NULL);
   EXPECT_EQ(12345.678, remote_report->timestamp());
 }
 
 // This test verifies that the empty track report exists in the returned stats
 // when StatsCollector::UpdateStats is called with ssrc stats.
 TEST_F(StatsCollectorTest, ReportsFromRemoteTrack) {
   StatsCollectorForTest stats(&session_);
 
+  EXPECT_CALL(session_, GetLocalCertificate(_, _))
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
+      .WillRepeatedly(Return(false));
+
   const char kVideoChannelName[] = "video";
   InitSessionStats(kVideoChannelName);
   EXPECT_CALL(session_, GetTransportStats(_))
       .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
                             Return(true)));
-  EXPECT_CALL(session_, GetTransport(_))
-      .WillRepeatedly(Return(static_cast<cricket::Transport*>(NULL)));
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_channel, NULL, kVideoChannelName, false);
   AddIncomingVideoTrackStats();
   stats.AddStream(stream_);
 
   // Constructs an ssrc stats update.
   cricket::VideoReceiverInfo video_receiver_info;
   cricket::VideoMediaInfo stats_read;
@@ skipping 158 matching lines @@
 
   TestCertificateReports(local_cert, std::vector<std::string>(1, local_der),
                          remote_cert, std::vector<std::string>(1, remote_der));
 }
 
 // This test verifies that the stats are generated correctly when no
 // transport is present.
 TEST_F(StatsCollectorTest, NoTransport) {
   StatsCollectorForTest stats(&session_);
 
+  EXPECT_CALL(session_, GetLocalCertificate(_, _))
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
+      .WillRepeatedly(Return(false));
+
   StatsReports reports;  // returned values.
 
   // Fake stats to process.
   cricket::TransportChannelStats channel_stats;
   channel_stats.component = 1;
 
   cricket::TransportStats transport_stats;
-  transport_stats.content_name = "audio";
+  transport_stats.transport_name = "audio";
   transport_stats.channel_stats.push_back(channel_stats);
 
   cricket::SessionStats session_stats;
-  session_stats.transport_stats[transport_stats.content_name] =
+  session_stats.transport_stats[transport_stats.transport_name] =
       transport_stats;
 
   // Configure MockWebRtcSession
-  EXPECT_CALL(session_, GetTransport(transport_stats.content_name))
-    .WillRepeatedly(ReturnNull());
   EXPECT_CALL(session_, GetTransportStats(_))
     .WillOnce(DoAll(SetArgPointee<0>(session_stats),
                     Return(true)));
 
   EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
   EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   stats.GetStats(NULL, &reports);
 
@@ skipping 22 matching lines @@
       reports,
       StatsReport::kStatsValueNameSrtpCipher);
   ASSERT_EQ(kNotFound, srtp_cipher);
 }
 
 // This test verifies that the stats are generated correctly when the transport
 // does not have any certificates.
 TEST_F(StatsCollectorTest, NoCertificates) {
   StatsCollectorForTest stats(&session_);
 
+  EXPECT_CALL(session_, GetLocalCertificate(_, _))
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
+      .WillRepeatedly(Return(false));
+
   StatsReports reports;  // returned values.
 
   // Fake stats to process.
   cricket::TransportChannelStats channel_stats;
   channel_stats.component = 1;
 
   cricket::TransportStats transport_stats;
-  transport_stats.content_name = "audio";
+  transport_stats.transport_name = "audio";
   transport_stats.channel_stats.push_back(channel_stats);
 
   cricket::SessionStats session_stats;
-  session_stats.transport_stats[transport_stats.content_name] =
+  session_stats.transport_stats[transport_stats.transport_name] =
       transport_stats;
 
   // Fake transport object.
   rtc::scoped_ptr<cricket::FakeTransport> transport(
-      new cricket::FakeTransport(
-          session_.signaling_thread(),
-          session_.worker_thread(),
-          transport_stats.content_name));
+      new cricket::FakeTransport(transport_stats.transport_name));
 
   // Configure MockWebRtcSession
-  EXPECT_CALL(session_, GetTransport(transport_stats.content_name))
-    .WillRepeatedly(Return(transport.get()));
   EXPECT_CALL(session_, GetTransportStats(_))
     .WillOnce(DoAll(SetArgPointee<0>(session_stats),
                     Return(true)));
   EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
   EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   stats.GetStats(NULL, &reports);
 
   // Check that the local certificate is absent.
@@ skipping 25 matching lines @@
 
   TestCertificateReports(local_cert, std::vector<std::string>(1, local_der),
                          remote_cert, std::vector<std::string>());
 }
 
 // This test verifies that a local stats object can get statistics via
 // AudioTrackInterface::GetStats() method.
 TEST_F(StatsCollectorTest, GetStatsFromLocalAudioTrack) {
   StatsCollectorForTest stats(&session_);
 
-  // Ignore unused callback (logspam).
-  EXPECT_CALL(session_, GetTransport(_))
-      .WillRepeatedly(Return(static_cast<cricket::Transport*>(NULL)));
+  EXPECT_CALL(session_, GetLocalCertificate(_, _))
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
+      .WillRepeatedly(Return(false));
 
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
-  // The content_name known by the voice channel.
+  // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
       media_engine_, media_channel, NULL, kVcName, false);
   AddOutgoingAudioTrackStats();
   stats.AddStream(stream_);
   stats.AddLocalAudioTrack(audio_track_, kSsrcOfTrack);
 
   cricket::VoiceSenderInfo voice_sender_info;
   InitVoiceSenderInfo(&voice_sender_info);
 
   cricket::VoiceMediaInfo stats_read;
   StatsReports reports;  // returned values.
   SetupAndVerifyAudioTrackStats(
       audio_track_.get(), stream_.get(), &stats, &voice_channel, kVcName,
       media_channel, &voice_sender_info, NULL, &stats_read, &reports);
 
   // Verify that there is no remote report for the local audio track because
   // we did not set it up.
   const StatsReport* remote_report = FindNthReportByType(reports,
       StatsReport::kStatsReportTypeRemoteSsrc, 1);
   EXPECT_TRUE(remote_report == NULL);
 }
 
 // This test verifies that audio receive streams populate stats reports
 // correctly.
 TEST_F(StatsCollectorTest, GetStatsFromRemoteStream) {
   StatsCollectorForTest stats(&session_);
 
-  // Ignore unused callback (logspam).
-  EXPECT_CALL(session_, GetTransport(_))
-      .WillRepeatedly(Return(static_cast<cricket::Transport*>(NULL)));
+  EXPECT_CALL(session_, GetLocalCertificate(_, _))
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
+      .WillRepeatedly(Return(false));
+
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
-  // The content_name known by the voice channel.
+  // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
       media_engine_, media_channel, NULL, kVcName, false);
   AddIncomingAudioTrackStats();
   stats.AddStream(stream_);
 
   cricket::VoiceReceiverInfo voice_receiver_info;
   InitVoiceReceiverInfo(&voice_receiver_info);
   voice_receiver_info.codec_name = "fake_codec";
 
   cricket::VoiceMediaInfo stats_read;
   StatsReports reports;  // returned values.
   SetupAndVerifyAudioTrackStats(
       audio_track_.get(), stream_.get(), &stats, &voice_channel, kVcName,
       media_channel, NULL, &voice_receiver_info, &stats_read, &reports);
 }
 
 // This test verifies that a local stats object won't update its statistics
 // after a RemoveLocalAudioTrack() call.
 TEST_F(StatsCollectorTest, GetStatsAfterRemoveAudioStream) {
   StatsCollectorForTest stats(&session_);
 
-  // Ignore unused callback (logspam).
-  EXPECT_CALL(session_, GetTransport(_))
-      .WillRepeatedly(Return(static_cast<cricket::Transport*>(NULL)));
+  EXPECT_CALL(session_, GetLocalCertificate(_, _))
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
+      .WillRepeatedly(Return(false));
+
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
-  // The content_name known by the voice channel.
+  // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
       media_engine_, media_channel, NULL, kVcName, false);
   AddOutgoingAudioTrackStats();
   stats.AddStream(stream_);
   stats.AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
 
   // Instruct the session to return stats containing the transport channel.
   InitSessionStats(kVcName);
   EXPECT_CALL(session_, GetTransportStats(_))
@@ skipping 34 matching lines @@
   // AudioTrackInterface::GetSignalValue() and
   // AudioProcessorInterface::AudioProcessorStats::GetStats();
   VerifyVoiceSenderInfoReport(report, voice_sender_info);
 }
 
 // This test verifies that when ongoing and incoming audio tracks are using
 // the same ssrc, they populate stats reports correctly.
 TEST_F(StatsCollectorTest, LocalAndRemoteTracksWithSameSsrc) {
   StatsCollectorForTest stats(&session_);
 
-  // Ignore unused callback (logspam).
-  EXPECT_CALL(session_, GetTransport(_))
-      .WillRepeatedly(Return(static_cast<cricket::Transport*>(NULL)));
+  EXPECT_CALL(session_, GetLocalCertificate(_, _))
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
+      .WillRepeatedly(Return(false));
+
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
-  // The content_name known by the voice channel.
+  // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
       media_engine_, media_channel, NULL, kVcName, false);
 
   // Create a local stream with a local audio track and adds it to the stats.
   AddOutgoingAudioTrackStats();
   stats.AddStream(stream_);
   stats.AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
 
   // Create a remote stream with a remote audio track and adds it to the stats.
@@ skipping 60 matching lines @@
   VerifyVoiceReceiverInfoReport(track_report, voice_receiver_info);
 }
 
 // This test verifies that when two outgoing audio tracks are using the same
 // ssrc at different times, they populate stats reports correctly.
 // TODO(xians): Figure out if it is possible to encapsulate the setup and
 // avoid duplication of code in test cases.
 TEST_F(StatsCollectorTest, TwoLocalTracksWithSameSsrc) {
   StatsCollectorForTest stats(&session_);
 
-  // Ignore unused callback (logspam).
-  EXPECT_CALL(session_, GetTransport(_))
-      .WillRepeatedly(Return(static_cast<cricket::Transport*>(NULL)));
+  EXPECT_CALL(session_, GetLocalCertificate(_, _))
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
+      .WillRepeatedly(Return(false));
+
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
-  // The content_name known by the voice channel.
+  // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
       media_engine_, media_channel, NULL, kVcName, false);
 
   // Create a local stream with a local audio track and adds it to the stats.
   AddOutgoingAudioTrackStats();
   stats.AddStream(stream_);
   stats.AddLocalAudioTrack(audio_track_, kSsrcOfTrack);
 
   cricket::VoiceSenderInfo voice_sender_info;
@@ skipping 22 matching lines @@
   cricket::VoiceSenderInfo new_voice_sender_info;
   InitVoiceSenderInfo(&new_voice_sender_info);
   cricket::VoiceMediaInfo new_stats_read;
   reports.clear();
   SetupAndVerifyAudioTrackStats(
       new_audio_track.get(), stream_.get(), &stats, &voice_channel, kVcName,
       media_channel, &new_voice_sender_info, NULL, &new_stats_read, &reports);
 }
 
 }  // namespace webrtc