Reland of Moving MediaStreamSignaling logic into PeerConnection.

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,
@@ skipping 13 matching lines @@
  * 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/peerconnection.h"
+#include "talk/app/webrtc/peerconnectionfactory.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/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/faketransportcontroller.h"
 
 using rtc::scoped_ptr;
 using testing::_;
 using testing::DoAll;
 using testing::Field;
 using testing::Return;
 using testing::ReturnNull;
+using testing::ReturnRef;
 using testing::SetArgPointee;
 using webrtc::PeerConnectionInterface;
 using webrtc::StatsReport;
 using webrtc::StatsReports;
 
 namespace {
 // This value comes from openssl/tls1.h
 const int TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014;
 }  // namespace
 
 namespace cricket {
 
 class ChannelManager;
 
 }  // namespace cricket
 
 namespace webrtc {
 
 // Error return values
 const char kNotFound[] = "NOT FOUND";
 
 // Constant names for track identification.
 const char kLocalTrackId[] = "local_track_id";
 const char kRemoteTrackId[] = "remote_track_id";
 const uint32_t kSsrcOfTrack = 1234;
 
 class MockWebRtcSession : public webrtc::WebRtcSession {
  public:
   explicit MockWebRtcSession(cricket::ChannelManager* channel_manager)
-    : WebRtcSession(channel_manager, rtc::Thread::Current(),
-                    rtc::Thread::Current(), NULL, NULL) {
-  }
+      : WebRtcSession(channel_manager,
+                      rtc::Thread::Current(),
+                      rtc::Thread::Current(),
+                      nullptr) {}
   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_t, std::string*));
   MOCK_METHOD2(GetRemoteTrackIdBySsrc, bool(uint32_t, std::string*));
   MOCK_METHOD1(GetTransportStats, bool(cricket::SessionStats*));
   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));
 };
 
+// The factory isn't really used; it just satisfies the base PeerConnection.
+class FakePeerConnectionFactory
+    : public rtc::RefCountedObject<PeerConnectionFactory> {};
+
+class MockPeerConnection
+    : public rtc::RefCountedObject<webrtc::PeerConnection> {
+ public:
+  MockPeerConnection()
+      : rtc::RefCountedObject<webrtc::PeerConnection>(
+            new FakePeerConnectionFactory()) {}
+  MOCK_METHOD0(session, WebRtcSession*());
+  MOCK_CONST_METHOD0(sctp_data_channels,
+                     const std::vector<rtc::scoped_refptr<DataChannel>>&());
+};
+
 class MockVideoMediaChannel : public cricket::FakeVideoMediaChannel {
  public:
   MockVideoMediaChannel() :
       cricket::FakeVideoMediaChannel(NULL, cricket::VideoOptions()) {}
   MOCK_METHOD1(GetStats, bool(cricket::VideoMediaInfo*));
 };
 
 class MockVoiceMediaChannel : public cricket::FakeVoiceMediaChannel {
  public:
   MockVoiceMediaChannel() :
@@ skipping 350 matching lines @@
   voice_receiver_info->audio_level = 120;
   voice_receiver_info->expand_rate = 121;
   voice_receiver_info->speech_expand_rate = 122;
   voice_receiver_info->secondary_decoded_rate = 123;
   voice_receiver_info->accelerate_rate = 124;
   voice_receiver_info->preemptive_expand_rate = 125;
 }
 
 class StatsCollectorForTest : public webrtc::StatsCollector {
  public:
-  explicit StatsCollectorForTest(WebRtcSession* session) :
-      StatsCollector(session), time_now_(19477) {
-  }
+  explicit StatsCollectorForTest(PeerConnection* pc)
+      : StatsCollector(pc), time_now_(19477) {}
 
   double GetTimeNow() override {
     return time_now_;
   }
 
  private:
   double time_now_;
 };
 
 class StatsCollectorTest : public testing::Test {
  protected:
   StatsCollectorTest()
-    : media_engine_(new cricket::FakeMediaEngine()),
-      channel_manager_(
-          new cricket::ChannelManager(media_engine_, rtc::Thread::Current())),
-      session_(channel_manager_.get()),
-      signaling_(channel_manager_.get()) {
+      : media_engine_(new cricket::FakeMediaEngine()),
+        channel_manager_(
+            new cricket::ChannelManager(media_engine_, rtc::Thread::Current())),
+        session_(channel_manager_.get()) {
     // By default, we ignore session GetStats calls.
     EXPECT_CALL(session_, GetTransportStats(_)).WillRepeatedly(Return(false));
-    EXPECT_CALL(session_, mediastream_signaling()).WillRepeatedly(
-        Return(&signaling_));
+    // Add default returns for mock classes.
+    EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
+    EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
+    EXPECT_CALL(pc_, session()).WillRepeatedly(Return(&session_));
+    EXPECT_CALL(pc_, sctp_data_channels())
+        .WillRepeatedly(ReturnRef(data_channels_));
   }
 
   ~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;
@@ skipping 41 matching lines @@
     if (stream_ == NULL)
       stream_ = webrtc::MediaStream::Create("streamlabel");
 
     audio_track_ = new rtc::RefCountedObject<FakeAudioTrack>(
         kRemoteTrackId);
     stream_->AddTrack(audio_track_);
     EXPECT_CALL(session_, GetRemoteTrackIdBySsrc(kSsrcOfTrack, _))
         .WillOnce(DoAll(SetArgPointee<1>(kRemoteTrackId), Return(true)));
   }
 
+  void AddDataChannel(cricket::DataChannelType type,
+                      const std::string& label,
+                      int id) {
+    InternalDataChannelInit config;
+    config.id = id;
+
+    data_channels_.push_back(DataChannel::Create(
+        &data_channel_provider_, cricket::DCT_SCTP, label, config));
+  }
+
   StatsReport* AddCandidateReport(StatsCollector* collector,
                                   const cricket::Candidate& candidate,
                                   bool local) {
     return collector->AddCandidateReport(candidate, local);
   }
 
   void SetupAndVerifyAudioTrackStats(
       FakeAudioTrack* audio_track,
       webrtc::MediaStream* stream,
       webrtc::StatsCollector* stats,
@@ skipping 67 matching lines @@
     if (voice_sender_info)
       VerifyVoiceSenderInfoReport(track_report, *voice_sender_info);
     if (voice_receiver_info)
     VerifyVoiceReceiverInfoReport(track_report, *voice_receiver_info);
   }
 
   void TestCertificateReports(const rtc::FakeSSLCertificate& local_cert,
                               const std::vector<std::string>& local_ders,
                               const rtc::FakeSSLCertificate& remote_cert,
                               const std::vector<std::string>& remote_ders) {
-    StatsCollectorForTest stats(&session_);
+    StatsCollectorForTest stats(&pc_);
 
     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 = TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA;
 
     cricket::TransportStats transport_stats;
@@ skipping 14 matching lines @@
     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);
 
     const StatsReport* channel_report = FindNthReportByType(
         reports, StatsReport::kStatsReportTypeComponent, 1);
     EXPECT_TRUE(channel_report != NULL);
 
     // Check local certificate chain.
@@ skipping 33 matching lines @@
     std::string srtp_cipher = ExtractStatsValue(
         StatsReport::kStatsReportTypeComponent,
         reports,
         StatsReport::kStatsValueNameSrtpCipher);
     EXPECT_EQ("the-srtp-cipher", srtp_cipher);
   }
 
   cricket::FakeMediaEngine* media_engine_;
   rtc::scoped_ptr<cricket::ChannelManager> channel_manager_;
   MockWebRtcSession session_;
-  FakeMediaStreamSignaling signaling_;
+  MockPeerConnection pc_;
   FakeDataChannelProvider data_channel_provider_;
   cricket::SessionStats session_stats_;
   rtc::scoped_refptr<webrtc::MediaStream> stream_;
   rtc::scoped_refptr<webrtc::VideoTrack> track_;
   rtc::scoped_refptr<FakeAudioTrack> audio_track_;
+  std::vector<rtc::scoped_refptr<DataChannel>> data_channels_;
 };
 
 // Verify that ExtractDataInfo populates reports.
 TEST_F(StatsCollectorTest, ExtractDataInfo) {
   const std::string label = "hacks";
   const int id = 31337;
   const std::string state = DataChannelInterface::DataStateString(
       DataChannelInterface::DataState::kConnecting);
 
-  EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
-  EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
-
-  InternalDataChannelInit config;
-  config.id = id;
-  signaling_.AddDataChannel(DataChannel::Create(
-      &data_channel_provider_, cricket::DCT_SCTP, label, config));
-  StatsCollectorForTest stats(&session_);
+  AddDataChannel(cricket::DCT_SCTP, label, id);
+  StatsCollectorForTest stats(&pc_);
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
 
   StatsReports reports;
   stats.GetStats(NULL, &reports);
 
   const StatsReport* report =
       FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1);
 
   StatsReport::Id reportId = StatsReport::NewTypedIntId(
@@ skipping 11 matching lines @@
   EXPECT_EQ(state, ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel,
                                      reports,
                                      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_);
+  StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
       .WillRepeatedly(Return(false));
 
   const char kVideoChannelName[] = "video";
 
   InitSessionStats(kVideoChannelName);
   EXPECT_CALL(session_, GetTransportStats(_))
@@ skipping 25 matching lines @@
                       Return(true)));
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   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_);
+  StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
       .WillRepeatedly(Return(false));
 
   const char kVideoChannelName[] = "video";
 
   InitSessionStats(kVideoChannelName);
   EXPECT_CALL(session_, GetTransportStats(_))
@@ skipping 36 matching lines @@
       StatsReport::kStatsValueNameBytesSent);
   EXPECT_EQ(kBytesSentString, result);
   result = ExtractBweStatsValue(reports,
       StatsReport::kStatsValueNameTargetEncBitrate);
   EXPECT_EQ(kTargetEncBitrateString, result);
 }
 
 // This test verifies that an object of type "googSession" always
 // exists in the returned stats.
 TEST_F(StatsCollectorTest, SessionObjectExists) {
-  StatsCollectorForTest stats(&session_);
+  StatsCollectorForTest stats(&pc_);
 
   StatsReports reports;  // returned values.
-  EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
-  EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   stats.GetStats(NULL, &reports);
   const StatsReport* session_report = FindNthReportByType(
       reports, StatsReport::kStatsReportTypeSession, 1);
   EXPECT_FALSE(session_report == NULL);
 }
 
 // This test verifies that only one object of type "googSession" exists
 // in the returned stats.
 TEST_F(StatsCollectorTest, OnlyOneSessionObjectExists) {
-  StatsCollectorForTest stats(&session_);
+  StatsCollectorForTest stats(&pc_);
 
   StatsReports reports;  // returned values.
-  EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
-  EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   stats.GetStats(NULL, &reports);
   const StatsReport* session_report = FindNthReportByType(
       reports, StatsReport::kStatsReportTypeSession, 1);
   EXPECT_FALSE(session_report == NULL);
   session_report = FindNthReportByType(
       reports, StatsReport::kStatsReportTypeSession, 2);
   EXPECT_EQ(NULL, session_report);
 }
 
 // This test verifies that the empty track report exists in the returned stats
 // without calling StatsCollector::UpdateStats.
 TEST_F(StatsCollectorTest, TrackObjectExistsWithoutUpdateStats) {
-  StatsCollectorForTest stats(&session_);
+  StatsCollectorForTest stats(&pc_);
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
       media_channel, NULL, "video", false);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
 
   // Verfies the existence of the track report.
   StatsReports reports;
   stats.GetStats(NULL, &reports);
   EXPECT_EQ((size_t)1, reports.size());
   EXPECT_EQ(StatsReport::kStatsReportTypeTrack, reports[0]->type());
   EXPECT_EQ(0, reports[0]->timestamp());
 
   std::string trackValue =
       ExtractStatsValue(StatsReport::kStatsReportTypeTrack,
                         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_);
+  StatsCollectorForTest stats(&pc_);
 
   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_),
@@ skipping 47 matching lines @@
   EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
 
   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_);
+  StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
       .WillRepeatedly(Return(false));
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   // The transport_name known by the video channel.
   const std::string kVcName("vcname");
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
@@ skipping 42 matching lines @@
   content = content.substr(0, index);
   StatsReport::Id id(StatsReport::NewComponentId(content, 1));
   ASSERT_EQ(transport_id, id->ToString());
   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_);
+  StatsCollectorForTest stats(&pc_);
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   // 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_);
+  StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
       .WillRepeatedly(Return(false));
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   // The transport_name known by the video channel.
   const std::string kVcName("vcname");
   cricket::VideoChannel video_channel(rtc::Thread::Current(),
@@ skipping 30 matching lines @@
 
   const StatsReport* remote_report = FindNthReportByType(reports,
       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_);
+  StatsCollectorForTest stats(&pc_);
 
   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_),
@@ skipping 37 matching lines @@
   EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
 
   std::string track_id = ExtractSsrcStatsValue(
       reports, StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kRemoteTrackId, track_id);
 }
 
 // This test verifies the Ice Candidate report should contain the correct
 // information from local/remote candidates.
 TEST_F(StatsCollectorTest, IceCandidateReport) {
-  StatsCollectorForTest stats(&session_);
+  StatsCollectorForTest stats(&pc_);
 
   StatsReports reports;                     // returned values.
 
   const int local_port = 2000;
   const char local_ip[] = "192.168.0.1";
   const int remote_port = 2001;
   const char remote_ip[] = "192.168.0.2";
 
   rtc::SocketAddress local_address(local_ip, local_port);
   rtc::SocketAddress remote_address(remote_ip, remote_port);
@@ skipping 109 matching lines @@
   std::string remote_der = "This is somebody else's der.";
   rtc::FakeSSLCertificate remote_cert(DerToPem(remote_der));
 
   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_);
+  StatsCollectorForTest stats(&pc_);
 
   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.transport_name = "audio";
   transport_stats.channel_stats.push_back(channel_stats);
 
   cricket::SessionStats session_stats;
   session_stats.transport_stats[transport_stats.transport_name] =
       transport_stats;
 
   // Configure MockWebRtcSession
   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.
   std::string local_certificate_id = ExtractStatsValue(
       StatsReport::kStatsReportTypeComponent,
       reports,
       StatsReport::kStatsValueNameLocalCertificateId);
   ASSERT_EQ(kNotFound, local_certificate_id);
 
@@ skipping 13 matching lines @@
   std::string srtp_cipher = ExtractStatsValue(
       StatsReport::kStatsReportTypeComponent,
       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_);
+  StatsCollectorForTest stats(&pc_);
 
   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.transport_name = "audio";
   transport_stats.channel_stats.push_back(channel_stats);
 
   cricket::SessionStats session_stats;
   session_stats.transport_stats[transport_stats.transport_name] =
       transport_stats;
 
   // Fake transport object.
   rtc::scoped_ptr<cricket::FakeTransport> transport(
       new cricket::FakeTransport(transport_stats.transport_name));
 
   // Configure MockWebRtcSession
   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.
   std::string local_certificate_id = ExtractStatsValue(
       StatsReport::kStatsReportTypeComponent,
       reports,
       StatsReport::kStatsValueNameLocalCertificateId);
   ASSERT_EQ(kNotFound, local_certificate_id);
 
@@ skipping 17 matching lines @@
   rtc::FakeSSLCertificate remote_cert(DerToPem(remote_der));
   remote_cert.set_digest_algorithm("foobar");
 
   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_);
+  StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
       .WillRepeatedly(Return(false));
 
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
@@ skipping 14 matching lines @@
   // 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_);
+  StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
       .WillRepeatedly(Return(false));
 
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // 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_);
+  StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
       .WillRepeatedly(Return(false));
 
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
@@ skipping 40 matching lines @@
 
   // Verifies the values in the track report, no value will be changed by the
   // 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_);
+  StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
       .WillRepeatedly(Return(false));
 
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
@@ skipping 66 matching lines @@
                                    StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kRemoteTrackId, track_id);
   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_);
+  StatsCollectorForTest stats(&pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
       .WillRepeatedly(Return(false));
 
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
@@ skipping 30 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