Mark template class RefCountedObject as final.

pc/rtcstatscollector_unittest.cc

 /*
  *  Copyright 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 267 matching lines @@
   RTCStatsCollectorTestHelper()
       : worker_thread_(rtc::Thread::Current()),
         network_thread_(rtc::Thread::Current()),
         signaling_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()),
-        pc_() {
+        pc_(new rtc::RefCountedObject<MockPeerConnection>()) {
     // Default return values for mocks.
-    EXPECT_CALL(pc_, local_streams()).WillRepeatedly(Return(nullptr));
-    EXPECT_CALL(pc_, remote_streams()).WillRepeatedly(Return(nullptr));
-    EXPECT_CALL(pc_, session()).WillRepeatedly(Return(&session_));
-    EXPECT_CALL(pc_, GetSenders()).WillRepeatedly(Return(
+    EXPECT_CALL(*pc_, local_streams()).WillRepeatedly(Return(nullptr));
+    EXPECT_CALL(*pc_, remote_streams()).WillRepeatedly(Return(nullptr));
+    EXPECT_CALL(*pc_, session()).WillRepeatedly(Return(&session_));
+    EXPECT_CALL(*pc_, 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>>()));
-    EXPECT_CALL(pc_, sctp_data_channels()).WillRepeatedly(
+    EXPECT_CALL(*pc_, sctp_data_channels()).WillRepeatedly(
         ReturnRef(data_channels_));
     EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
     EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
     EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(ReturnNull());
     EXPECT_CALL(session_, GetLocalCertificate(_, _)).WillRepeatedly(
         Return(false));
     EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))
         .WillRepeatedly(Return(nullptr));
   }
 
   rtc::ScopedFakeClock& fake_clock() { return fake_clock_; }
   rtc::Thread* worker_thread() { return worker_thread_; }
   rtc::Thread* network_thread() { return network_thread_; }
   rtc::Thread* signaling_thread() { return signaling_thread_; }
   cricket::FakeMediaEngine* media_engine() { return media_engine_; }
   MockWebRtcSession& session() { return session_; }
-  MockPeerConnection& pc() { return pc_; }
+  MockPeerConnection& pc() { return *pc_; }
   std::vector<rtc::scoped_refptr<DataChannel>>& data_channels() {
     return data_channels_;
   }
 
   // SetSessionDescriptionObserver overrides.
   void OnSuccess() override {}
   void OnFailure(const std::string& error) override {
     RTC_NOTREACHED() << error;
   }
 
   void SetupLocalTrackAndSender(cricket::MediaType media_type,
                                 const std::string& track_id,
                                 uint32_t ssrc) {
     rtc::scoped_refptr<StreamCollection> local_streams =
         StreamCollection::Create();
-    EXPECT_CALL(pc_, local_streams())
+    EXPECT_CALL(*pc_, local_streams())
         .WillRepeatedly(Return(local_streams));
 
     rtc::scoped_refptr<MediaStream> local_stream =
         MediaStream::Create("LocalStreamLabel");
     local_streams->AddStream(local_stream);
 
     rtc::scoped_refptr<MediaStreamTrackInterface> track;
     if (media_type == cricket::MEDIA_TYPE_AUDIO) {
       track = CreateFakeTrack(media_type, track_id,
                               MediaStreamTrackInterface::kLive);
       local_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get()));
     } else {
       track = CreateFakeTrack(media_type, track_id,
                               MediaStreamTrackInterface::kLive);
       local_stream->AddTrack(static_cast<VideoTrackInterface*>(track.get()));
     }
 
     rtc::scoped_refptr<MockRtpSender> sender = CreateMockSender(track, ssrc);
-    EXPECT_CALL(pc_, GetSenders()).WillRepeatedly(Return(
+    EXPECT_CALL(*pc_, GetSenders()).WillRepeatedly(Return(
         std::vector<rtc::scoped_refptr<RtpSenderInterface>>({
             rtc::scoped_refptr<RtpSenderInterface>(sender.get()) })));
   }
 
   void SetupRemoteTrackAndReceiver(cricket::MediaType media_type,
                                    const std::string& track_id,
                                    uint32_t ssrc) {
     rtc::scoped_refptr<StreamCollection> remote_streams =
         StreamCollection::Create();
-    EXPECT_CALL(pc_, remote_streams())
+    EXPECT_CALL(*pc_, remote_streams())
         .WillRepeatedly(Return(remote_streams));
 
     rtc::scoped_refptr<MediaStream> remote_stream =
         MediaStream::Create("RemoteStreamLabel");
     remote_streams->AddStream(remote_stream);
 
     rtc::scoped_refptr<MediaStreamTrackInterface> track;
     if (media_type == cricket::MEDIA_TYPE_AUDIO) {
       track = CreateFakeTrack(media_type, track_id,
                               MediaStreamTrackInterface::kLive);
       remote_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get()));
     } else {
       track = CreateFakeTrack(media_type, track_id,
                               MediaStreamTrackInterface::kLive);
       remote_stream->AddTrack(static_cast<VideoTrackInterface*>(track.get()));
     }
 
     rtc::scoped_refptr<MockRtpReceiver> receiver =
         CreateMockReceiver(track, ssrc);
-    EXPECT_CALL(pc_, GetReceivers()).WillRepeatedly(Return(
+    EXPECT_CALL(*pc_, GetReceivers()).WillRepeatedly(Return(
         std::vector<rtc::scoped_refptr<RtpReceiverInterface>>({
             rtc::scoped_refptr<RtpReceiverInterface>(receiver.get()) })));
   }
 
   // Attaches tracks to peer connections by configuring RTP senders and RTP
   // receivers according to the tracks' pairings with
   // |[Voice/Video][Sender/Receiver]Info| and their SSRCs. Local tracks can be
   // associated with multiple |[Voice/Video]SenderInfo|s, remote tracks can only
   // be associated with one |[Voice/Video]ReceiverInfo|.
   void CreateMockRtpSendersReceiversAndChannels(
@@ skipping 62 matching lines @@
                     MediaStreamTrackInterface::kVideoKind);
 
       video_media_info_->receivers.push_back(video_receiver_info);
       rtc::scoped_refptr<MockRtpReceiver> rtp_receiver =
           CreateMockReceiver(rtc::scoped_refptr<MediaStreamTrackInterface>(
                                remote_video_track),
                              video_receiver_info.local_stats[0].ssrc);
       rtp_receivers_.push_back(rtc::scoped_refptr<RtpReceiverInterface>(
           rtp_receiver.get()));
     }
-    EXPECT_CALL(pc_, GetSenders()).WillRepeatedly(Return(rtp_senders_));
-    EXPECT_CALL(pc_, GetReceivers()).WillRepeatedly(Return(rtp_receivers_));
+    EXPECT_CALL(*pc_, GetSenders()).WillRepeatedly(Return(rtp_senders_));
+    EXPECT_CALL(*pc_, GetReceivers()).WillRepeatedly(Return(rtp_receivers_));
 
     MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel();
     voice_channel_.reset(new cricket::VoiceChannel(
         worker_thread_, network_thread_, nullptr, media_engine_,
         voice_media_channel, "VoiceContentName", kDefaultRtcpMuxRequired,
         kDefaultSrtpRequired));
     EXPECT_CALL(session_, voice_channel())
         .WillRepeatedly(Return(voice_channel_.get()));
     EXPECT_CALL(*voice_media_channel, GetStats(_))
         .WillOnce(DoAll(SetArgPointee<0>(*voice_media_info_), Return(true)));
@@ skipping 11 matching lines @@
  private:
   rtc::ScopedFakeClock fake_clock_;
   RtcEventLogNullImpl event_log_;
   rtc::Thread* const worker_thread_;
   rtc::Thread* const network_thread_;
   rtc::Thread* const signaling_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_;
 
   std::vector<rtc::scoped_refptr<DataChannel>> data_channels_;
   std::unique_ptr<cricket::VoiceChannel> voice_channel_;
   std::unique_ptr<cricket::VideoChannel> video_channel_;
   std::unique_ptr<cricket::VoiceMediaInfo> voice_media_info_;
   std::unique_ptr<cricket::VideoMediaInfo> video_media_info_;
   std::vector<rtc::scoped_refptr<RtpSenderInterface>> rtp_senders_;
   std::vector<rtc::scoped_refptr<RtpReceiverInterface>> rtp_receivers_;
 };
 
@@ skipping 466 matching lines @@
         return static_cast<rtc::SSLCertificate*>(nullptr);
       }));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
   ExpectReportContainsCertificateInfo(report, *local_certinfo);
   ExpectReportContainsCertificateInfo(report, *remote_certinfo);
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
   test_->data_channels().push_back(
-      new MockDataChannel(
+      new rtc::RefCountedObject<MockDataChannel>(
           0, "MockDataChannel0", DataChannelInterface::kConnecting, "udp",
           1, 2, 3, 4));
   RTCDataChannelStats expected_data_channel0("RTCDataChannel_0", 0);
   expected_data_channel0.label = "MockDataChannel0";
   expected_data_channel0.protocol = "udp";
   expected_data_channel0.datachannelid = 0;
   expected_data_channel0.state = "connecting";
   expected_data_channel0.messages_sent = 1;
   expected_data_channel0.bytes_sent = 2;
   expected_data_channel0.messages_received = 3;
   expected_data_channel0.bytes_received = 4;
 
   test_->data_channels().push_back(
-      new MockDataChannel(
+      new rtc::RefCountedObject<MockDataChannel>(
           1, "MockDataChannel1", DataChannelInterface::kOpen, "tcp",
           5, 6, 7, 8));
   RTCDataChannelStats expected_data_channel1("RTCDataChannel_1", 0);
   expected_data_channel1.label = "MockDataChannel1";
   expected_data_channel1.protocol = "tcp";
   expected_data_channel1.datachannelid = 1;
   expected_data_channel1.state = "open";
   expected_data_channel1.messages_sent = 5;
   expected_data_channel1.bytes_sent = 6;
   expected_data_channel1.messages_received = 7;
   expected_data_channel1.bytes_received = 8;
 
   test_->data_channels().push_back(
-      new MockDataChannel(
+      new rtc::RefCountedObject<MockDataChannel>(
           2, "MockDataChannel2", DataChannelInterface::kClosing, "udp",
           9, 10, 11, 12));
   RTCDataChannelStats expected_data_channel2("RTCDataChannel_2", 0);
   expected_data_channel2.label = "MockDataChannel2";
   expected_data_channel2.protocol = "udp";
   expected_data_channel2.datachannelid = 2;
   expected_data_channel2.state = "closing";
   expected_data_channel2.messages_sent = 9;
   expected_data_channel2.bytes_sent = 10;
   expected_data_channel2.messages_received = 11;
   expected_data_channel2.bytes_received = 12;
 
   test_->data_channels().push_back(
-      new MockDataChannel(
+      new rtc::RefCountedObject<MockDataChannel>(
           3, "MockDataChannel3", DataChannelInterface::kClosed, "tcp",
           13, 14, 15, 16));
   RTCDataChannelStats expected_data_channel3("RTCDataChannel_3", 0);
   expected_data_channel3.label = "MockDataChannel3";
   expected_data_channel3.protocol = "tcp";
   expected_data_channel3.datachannelid = 3;
   expected_data_channel3.state = "closed";
   expected_data_channel3.messages_sent = 13;
   expected_data_channel3.bytes_sent = 14;
   expected_data_channel3.messages_received = 15;
@@ skipping 1297 matching lines @@
   rtc::scoped_refptr<FakeRTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
   collector_->VerifyThreadUsageAndResultsMerging();
 }
 
 }  // namespace
 
 }  // namespace webrtc