Mark template class RefCountedObject as final.

pc/rtpsenderreceiver_unittest.cc

 /*
  *  Copyright 2012 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 114 matching lines @@
         VideoTrack::Create(kVideoTrackId, source, rtc::Thread::Current());
     EXPECT_TRUE(local_stream_->AddTrack(video_track_));
   }
 
   void CreateAudioRtpSender() { CreateAudioRtpSender(nullptr); }
 
   void CreateAudioRtpSender(rtc::scoped_refptr<LocalAudioSource> source) {
     audio_track_ = AudioTrack::Create(kAudioTrackId, source);
     EXPECT_TRUE(local_stream_->AddTrack(audio_track_));
     audio_rtp_sender_ =
-        new AudioRtpSender(local_stream_->GetAudioTracks()[0],
-                           {local_stream_->label()}, voice_channel_, nullptr);
+        new rtc::RefCountedObject<AudioRtpSender>(
+            local_stream_->GetAudioTracks()[0],
+            std::vector<std::string>({local_stream_->label()}),

[nisse-webrtc, 2017/09/18 08:28:57]

The compiler template magic failed without explicit construction of this vector,
it said it could infer the argument for the argument 
|{local_stream->label()}|.

Is there any nice way to fix that, and make RefCountedObject forward initializer
lists to the constructor of the underlying type?

[kwiberg-webrtc, 2017/09/18 09:13:50]

Not that I know of. See e.g.
https://stackoverflow.com/questions/28370970/forwarding-initializer-list-expr...

[nisse-webrtc, 2017/09/18 09:20:05]

Hmm. From there, it looks like it might work to write
std::initializer_list(local_stream_->label()) instead of std::vector.... But
that wouldn't improve readability, I'm afraid, even f it works.

+            voice_channel_, nullptr);
     audio_rtp_sender_->SetSsrc(kAudioSsrc);
     audio_rtp_sender_->GetOnDestroyedSignal()->connect(
         this, &RtpSenderReceiverTest::OnAudioSenderDestroyed);
     VerifyVoiceChannelInput();
   }
 
   void OnAudioSenderDestroyed() { audio_sender_destroyed_signal_fired_ = true; }
 
   void CreateVideoRtpSender() { CreateVideoRtpSender(false); }
 
   void CreateVideoRtpSender(bool is_screencast) {
     AddVideoTrack(is_screencast);
     video_rtp_sender_ =
-        new VideoRtpSender(local_stream_->GetVideoTracks()[0],
-                           {local_stream_->label()}, video_channel_);
+        new rtc::RefCountedObject<VideoRtpSender>(
+            local_stream_->GetVideoTracks()[0],
+            std::vector<std::string>({local_stream_->label()}), video_channel_);
     video_rtp_sender_->SetSsrc(kVideoSsrc);
     VerifyVideoChannelInput();
   }
 
   void DestroyAudioRtpSender() {
     audio_rtp_sender_ = nullptr;
     VerifyVoiceChannelNoInput();
   }
 
   void DestroyVideoRtpSender() {
     video_rtp_sender_ = nullptr;
     VerifyVideoChannelNoInput();
   }
 
   void CreateAudioRtpReceiver() {
-    audio_rtp_receiver_ =
-        new AudioRtpReceiver(kAudioTrackId, kAudioSsrc, voice_channel_);
+    audio_rtp_receiver_ = new rtc::RefCountedObject<AudioRtpReceiver>(
+        kAudioTrackId, kAudioSsrc, voice_channel_);
     audio_track_ = audio_rtp_receiver_->audio_track();
     VerifyVoiceChannelOutput();
   }
 
   void CreateVideoRtpReceiver() {
-    video_rtp_receiver_ = new VideoRtpReceiver(
+    video_rtp_receiver_ = new rtc::RefCountedObject<VideoRtpReceiver>(
         kVideoTrackId, rtc::Thread::Current(), kVideoSsrc, video_channel_);
     video_track_ = video_rtp_receiver_->video_track();
     VerifyVideoChannelOutput();
   }
 
   void DestroyAudioRtpReceiver() {
     audio_rtp_receiver_ = nullptr;
     VerifyVoiceChannelNoOutput();
   }
 
@@ skipping 217 matching lines @@
   audio_track_->GetSource()->SetVolume(0.9);
   EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
   EXPECT_EQ(0.9, volume);
 
   DestroyAudioRtpReceiver();
 }
 
 // Test that the media channel isn't enabled for sending if the audio sender
 // doesn't have both a track and SSRC.
 TEST_F(RtpSenderReceiverTest, AudioSenderWithoutTrackAndSsrc) {
-  audio_rtp_sender_ = new AudioRtpSender(voice_channel_, nullptr);
+  audio_rtp_sender_ =
+      new rtc::RefCountedObject<AudioRtpSender>(voice_channel_, nullptr);
   rtc::scoped_refptr<AudioTrackInterface> track =
       AudioTrack::Create(kAudioTrackId, nullptr);
 
   // Track but no SSRC.
   EXPECT_TRUE(audio_rtp_sender_->SetTrack(track));
   VerifyVoiceChannelNoInput();
 
   // SSRC but no track.
   EXPECT_TRUE(audio_rtp_sender_->SetTrack(nullptr));
   audio_rtp_sender_->SetSsrc(kAudioSsrc);
   VerifyVoiceChannelNoInput();
 }
 
 // Test that the media channel isn't enabled for sending if the video sender
 // doesn't have both a track and SSRC.
 TEST_F(RtpSenderReceiverTest, VideoSenderWithoutTrackAndSsrc) {
-  video_rtp_sender_ = new VideoRtpSender(video_channel_);
+  video_rtp_sender_ = new rtc::RefCountedObject<VideoRtpSender>(video_channel_);
 
   // Track but no SSRC.
   EXPECT_TRUE(video_rtp_sender_->SetTrack(video_track_));
   VerifyVideoChannelNoInput();
 
   // SSRC but no track.
   EXPECT_TRUE(video_rtp_sender_->SetTrack(nullptr));
   video_rtp_sender_->SetSsrc(kVideoSsrc);
   VerifyVideoChannelNoInput();
 }
 
 // Test that the media channel is enabled for sending when the audio sender
 // has a track and SSRC, when the SSRC is set first.
 TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupSsrcThenTrack) {
-  audio_rtp_sender_ = new AudioRtpSender(voice_channel_, nullptr);
+  audio_rtp_sender_ =
+      new rtc::RefCountedObject<AudioRtpSender>(voice_channel_, nullptr);
   rtc::scoped_refptr<AudioTrackInterface> track =
       AudioTrack::Create(kAudioTrackId, nullptr);
   audio_rtp_sender_->SetSsrc(kAudioSsrc);
   audio_rtp_sender_->SetTrack(track);
   VerifyVoiceChannelInput();
 
   DestroyAudioRtpSender();
 }
 
 // Test that the media channel is enabled for sending when the audio sender
 // has a track and SSRC, when the SSRC is set last.
 TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupTrackThenSsrc) {
-  audio_rtp_sender_ = new AudioRtpSender(voice_channel_, nullptr);
+  audio_rtp_sender_ =
+      new rtc::RefCountedObject<AudioRtpSender>(voice_channel_, nullptr);
   rtc::scoped_refptr<AudioTrackInterface> track =
       AudioTrack::Create(kAudioTrackId, nullptr);
   audio_rtp_sender_->SetTrack(track);
   audio_rtp_sender_->SetSsrc(kAudioSsrc);
   VerifyVoiceChannelInput();
 
   DestroyAudioRtpSender();
 }
 
 // Test that the media channel is enabled for sending when the video sender
 // has a track and SSRC, when the SSRC is set first.
 TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupSsrcThenTrack) {
   AddVideoTrack();
-  video_rtp_sender_ = new VideoRtpSender(video_channel_);
+  video_rtp_sender_ = new rtc::RefCountedObject<VideoRtpSender>(video_channel_);
   video_rtp_sender_->SetSsrc(kVideoSsrc);
   video_rtp_sender_->SetTrack(video_track_);
   VerifyVideoChannelInput();
 
   DestroyVideoRtpSender();
 }
 
 // Test that the media channel is enabled for sending when the video sender
 // has a track and SSRC, when the SSRC is set last.
 TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupTrackThenSsrc) {
   AddVideoTrack();
-  video_rtp_sender_ = new VideoRtpSender(video_channel_);
+  video_rtp_sender_ = new rtc::RefCountedObject<VideoRtpSender>(video_channel_);
   video_rtp_sender_->SetTrack(video_track_);
   video_rtp_sender_->SetSsrc(kVideoSsrc);
   VerifyVideoChannelInput();
 
   DestroyVideoRtpSender();
 }
 
 // Test that the media channel stops sending when the audio sender's SSRC is set
 // to 0.
 TEST_F(RtpSenderReceiverTest, AudioSenderSsrcSetToZero) {
@@ skipping 210 matching lines @@
 
 // Test that makes sure any content hints that are set on a track before
 // VideoRtpSender is ready to send are still applied when it gets ready to send.
 TEST_F(RtpSenderReceiverTest,
        PropagatesVideoTrackContentHintSetBeforeEnabling) {
   AddVideoTrack();
   // Setting detailed overrides the default non-screencast mode. This should be
   // applied even if the track is set on construction.
   video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed);
   video_rtp_sender_ =
-      new VideoRtpSender(local_stream_->GetVideoTracks()[0],
-                         {local_stream_->label()}, video_channel_);
+      new rtc::RefCountedObject<VideoRtpSender>(
+          local_stream_->GetVideoTracks()[0],
+          std::vector<std::string>({local_stream_->label()}), video_channel_);
   video_track_->set_enabled(true);
 
   // Sender is not ready to send (no SSRC) so no option should have been set.
   EXPECT_EQ(rtc::Optional<bool>(),
             video_media_channel_->options().is_screencast);
 
   // Verify that the content hint is accounted for when video_rtp_sender_ does
   // get enabled.
   video_rtp_sender_->SetSsrc(kVideoSsrc);
   EXPECT_EQ(rtc::Optional<bool>(true),
@@ skipping 64 matching lines @@
 // Make sure the signal from "GetOnDestroyedSignal()" fires when the sender is
 // destroyed, which is needed for the DTMF sender.
 TEST_F(RtpSenderReceiverTest, TestOnDestroyedSignal) {
   CreateAudioRtpSender();
   EXPECT_FALSE(audio_sender_destroyed_signal_fired_);
   audio_rtp_sender_ = nullptr;
   EXPECT_TRUE(audio_sender_destroyed_signal_fired_);
 }
 
 }  // namespace webrtc