Mark template class RefCountedObject as final.

pc/statscollector_unittest.cc

 /*
  *  Copyright 2014 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 554 matching lines @@
  protected:
   StatsCollectorTest()
       : worker_thread_(rtc::Thread::Current()),
         network_thread_(rtc::Thread::Current()),
         media_engine_(new cricket::FakeMediaEngine()),
         channel_manager_(new cricket::ChannelManager(
             std::unique_ptr<cricket::MediaEngineInterface>(media_engine_),
             worker_thread_,
             network_thread_)),
 
-        session_(channel_manager_.get(), cricket::MediaConfig()) {
+        session_(channel_manager_.get(), cricket::MediaConfig()),
+        pc_(new rtc::RefCountedObject<MockPeerConnection>()) {
     // By default, we ignore session GetStats calls.
     EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(ReturnNull());
     // 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())
+    EXPECT_CALL(*pc_, session()).WillRepeatedly(Return(&session_));
+    EXPECT_CALL(*pc_, sctp_data_channels())
         .WillRepeatedly(ReturnRef(data_channels_));
-    EXPECT_CALL(pc_, GetSenders()).WillRepeatedly(Return(
+    EXPECT_CALL(*pc_, GetSenders()).WillRepeatedly(Return(
         std::vector<rtc::scoped_refptr<RtpSenderInterface>>()));
-    EXPECT_CALL(pc_, GetReceivers()).WillRepeatedly(Return(
+    EXPECT_CALL(*pc_, GetReceivers()).WillRepeatedly(Return(
         std::vector<rtc::scoped_refptr<RtpReceiverInterface>>()));
   }
 
   ~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");
@@ skipping 150 matching lines @@
       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,
       std::unique_ptr<rtc::FakeSSLCertificate> remote_cert,
       const std::vector<std::string>& remote_ders) {
-    StatsCollectorForTest stats(&pc_);
+    StatsCollectorForTest stats(pc_);
 
     StatsReports reports;  // returned values.
 
     // Fake stats to process.
     cricket::TransportChannelStats channel_stats;
     channel_stats.component = 1;
     channel_stats.srtp_crypto_suite = rtc::SRTP_AES128_CM_SHA1_80;
     channel_stats.ssl_cipher_suite =
         internal::TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA;
 
@@ skipping 71 matching lines @@
               srtp_crypto_suite);
   }
 
   webrtc::RtcEventLogNullImpl event_log_;
   rtc::Thread* const worker_thread_;
   rtc::Thread* const network_thread_;
   // |media_engine_| is actually owned by |channel_manager_|.
   cricket::FakeMediaEngine* media_engine_;
   std::unique_ptr<cricket::ChannelManager> channel_manager_;
   MockWebRtcSession session_;
-  MockPeerConnection pc_;
+  rtc::scoped_refptr<MockPeerConnection> pc_;
   FakeDataChannelProvider data_channel_provider_;
   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_;
 };
 
 TEST_F(StatsCollectorTest, FilterOutNegativeDataChannelId) {
   const std::string label = "hacks";
   // The data channel id is from the Config which is -1 initially.
   const int id = -1;
   const std::string state = DataChannelInterface::DataStateString(
       DataChannelInterface::DataState::kConnecting);
 
   AddDataChannel(cricket::DCT_SCTP, label, id);
-  StatsCollectorForTest stats(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
 
   StatsReports reports;
   stats.GetStats(NULL, &reports);
 
   const StatsReport* report =
       FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1);
 
   std::string value_in_report;
   EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameDataChannelId,
                         &value_in_report));
 }
 
 // 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);
 
   AddDataChannel(cricket::DCT_SCTP, label, id);
-  StatsCollectorForTest stats(&pc_);
+  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(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   const char kVideoChannelName[] = "video";
 
   InitSessionStats(kVideoChannelName);
   EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(Invoke(
@@ skipping 28 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 audio BWE information is reported via stats.
 TEST_F(StatsCollectorTest, AudioBandwidthEstimationInfoIsReported) {
-  StatsCollectorForTest stats(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   const char kAudioChannelName[] = "audio";
 
   InitSessionStats(kAudioChannelName);
   EXPECT_CALL(session_, GetStats(_))
@@ skipping 46 matching lines @@
   result = ExtractBweStatsValue(
       reports, StatsReport::kStatsValueNameAvailableReceiveBandwidth);
   EXPECT_EQ(rtc::ToString(kRecvBandwidth), result);
   result =
       ExtractBweStatsValue(reports, StatsReport::kStatsValueNameBucketDelay);
   EXPECT_EQ(rtc::ToString(kPacerDelay), result);
 }
 
 // Test that video BWE information is reported via stats.
 TEST_F(StatsCollectorTest, VideoBandwidthEstimationInfoIsReported) {
-  StatsCollectorForTest stats(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   const char kVideoChannelName[] = "video";
 
   InitSessionStats(kVideoChannelName);
   EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(Invoke(
@@ skipping 48 matching lines @@
       reports, StatsReport::kStatsValueNameAvailableReceiveBandwidth);
   EXPECT_EQ(rtc::ToString(kRecvBandwidth), result);
   result =
       ExtractBweStatsValue(reports, StatsReport::kStatsValueNameBucketDelay);
   EXPECT_EQ(rtc::ToString(kPacerDelay), result);
 }
 
 // This test verifies that an object of type "googSession" always
 // exists in the returned stats.
 TEST_F(StatsCollectorTest, SessionObjectExists) {
-  StatsCollectorForTest stats(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   StatsReports reports;  // returned values.
   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(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   StatsReports reports;  // returned values.
   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(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(
       worker_thread_, network_thread_, nullptr, media_channel, "video",
       kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
   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(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   const char kVideoChannelName[] = "video";
   InitSessionStats(kVideoChannelName);
   EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(Invoke(
       [this](const ChannelNamePairs&) {
@@ skipping 54 matching lines @@
   EXPECT_EQ(kLocalTrackId, track_id);
 
   std::string media_type = ExtractSsrcStatsValue(reports,
       StatsReport::kStatsValueNameMediaType);
   EXPECT_EQ("video", media_type);
 }
 
 // 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(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   // The transport_name known by the video channel.
   const std::string kVcName("vcname");
   cricket::VideoChannel video_channel(
@@ skipping 45 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(&pc_);
+  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(
       worker_thread_, network_thread_, nullptr, media_channel, kVcName,
       kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
   AddOutgoingVideoTrackStats();
   stats.AddStream(stream_);
 
   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(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
   // The transport_name known by the video channel.
   const std::string kVcName("vcname");
   cricket::VideoChannel video_channel(
@@ skipping 33 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(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   const char kVideoChannelName[] = "video";
   InitSessionStats(kVideoChannelName);
   EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(Invoke(
       [this](const ChannelNamePairs&) {
@@ skipping 40 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(&pc_);
+  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 113 matching lines @@
       new rtc::FakeSSLCertificate(DerToPem(remote_der)));
 
   TestCertificateReports(local_cert, std::vector<std::string>(1, local_der),
                          std::move(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(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   StatsReports reports;  // returned values.
 
   // Fake stats to process.
   cricket::TransportChannelStats channel_stats;
@@ skipping 38 matching lines @@
   ASSERT_EQ(kNotFound, dtls_cipher_suite);
   std::string srtp_crypto_suite =
       ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
                         StatsReport::kStatsValueNameSrtpCipher);
   ASSERT_EQ(kNotFound, srtp_crypto_suite);
 }
 
 // This test verifies that the stats are generated correctly when the transport
 // does not have any certificates.
 TEST_F(StatsCollectorTest, NoCertificates) {
-  StatsCollectorForTest stats(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   StatsReports reports;  // returned values.
 
   // Fake stats to process.
   cricket::TransportChannelStats channel_stats;
@@ skipping 44 matching lines @@
       new rtc::FakeSSLCertificate(DerToPem(remote_der)));
   remote_cert->set_digest_algorithm("foobar");
 
   TestCertificateReports(local_cert, std::vector<std::string>(1, local_der),
                          std::move(remote_cert), std::vector<std::string>());
 }
 
 // This test verifies that the audio/video related stats which are -1 initially
 // will be filtered out.
 TEST_F(StatsCollectorTest, FilterOutNegativeInitialValues) {
-  StatsCollectorForTest stats(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(
@@ skipping 89 matching lines @@
   EXPECT_FALSE(GetValue(report,
                         StatsReport::kStatsValueNameCaptureStartNtpTimeMs,
                         &value_in_report));
   EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameAudioInputLevel,
                         &value_in_report));
 }
 
 // This test verifies that a local stats object can get statistics via
 // AudioTrackInterface::GetStats() method.
 TEST_F(StatsCollectorTest, GetStatsFromLocalAudioTrack) {
-  StatsCollectorForTest stats(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(
@@ skipping 15 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(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(
       worker_thread_, network_thread_, nullptr, media_engine_, media_channel,
       kVcName, kDefaultRtcpMuxRequired, kDefaultSrtpRequired);
   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(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(
@@ skipping 43 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(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(
@@ skipping 69 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(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
   // The transport_name known by the voice channel.
   const std::string kVcName("vcname");
   cricket::VoiceChannel voice_channel(
@@ skipping 33 matching lines @@
   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);
 }
 
 // This test verifies that stats are correctly set in video send ssrc stats.
 TEST_F(StatsCollectorTest, VerifyVideoSendSsrcStats) {
-  StatsCollectorForTest stats(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   const char kVideoChannelName[] = "video";
 
   InitSessionStats(kVideoChannelName);
   EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(Invoke(
@@ skipping 27 matching lines @@
   stats.GetStats(NULL, &reports);
   EXPECT_EQ(rtc::ToString(video_sender_info.frames_encoded),
             ExtractSsrcStatsValue(reports,
                                   StatsReport::kStatsValueNameFramesEncoded));
   EXPECT_EQ(rtc::ToString(*video_sender_info.qp_sum),
             ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameQpSum));
 }
 
 // This test verifies that stats are correctly set in video receive ssrc stats.
 TEST_F(StatsCollectorTest, VerifyVideoReceiveSsrcStats) {
-  StatsCollectorForTest stats(&pc_);
+  StatsCollectorForTest stats(pc_);
 
   EXPECT_CALL(session_, GetLocalCertificate(_, _))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
       .WillRepeatedly(Return(nullptr));
 
   const char kVideoChannelName[] = "video";
 
   InitSessionStats(kVideoChannelName);
   EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(Invoke(
@@ skipping 26 matching lines @@
   stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
   stats.GetStats(NULL, &reports);
   EXPECT_EQ(rtc::ToString(video_receiver_info.frames_decoded),
             ExtractSsrcStatsValue(reports,
                                   StatsReport::kStatsValueNameFramesDecoded));
   EXPECT_EQ(rtc::ToString(*video_receiver_info.qp_sum),
             ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameQpSum));
 }
 
 }  // namespace webrtc