Mark template class RefCountedObject as final.

pc/peerconnection.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 603 matching lines @@
   if (FindSenderForTrack(track) != senders_.end()) {
     LOG(LS_ERROR) << "Sender for track " << track->id() << " already exists.";
     return nullptr;
   }
 
   // TODO(deadbeef): Support adding a track to multiple streams.
   rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> new_sender;
   if (track->kind() == MediaStreamTrackInterface::kAudioKind) {
     new_sender = RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
         signaling_thread(),
-        new AudioRtpSender(static_cast<AudioTrackInterface*>(track),
-                           session_->voice_channel(), stats_.get()));
+        new rtc::RefCountedObject<AudioRtpSender>(
+            static_cast<AudioTrackInterface*>(track),
+            session_->voice_channel(), stats_.get()));
     if (!streams.empty()) {
       new_sender->internal()->set_stream_id(streams[0]->label());
     }
     const TrackInfo* track_info = FindTrackInfo(
         local_audio_tracks_, new_sender->internal()->stream_id(), track->id());
     if (track_info) {
       new_sender->internal()->SetSsrc(track_info->ssrc);
     }
   } else if (track->kind() == MediaStreamTrackInterface::kVideoKind) {
     new_sender = RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
         signaling_thread(),
-        new VideoRtpSender(static_cast<VideoTrackInterface*>(track),
-                           session_->video_channel()));
+        new rtc::RefCountedObject<VideoRtpSender>(
+            static_cast<VideoTrackInterface*>(track),
+            session_->video_channel()));
     if (!streams.empty()) {
       new_sender->internal()->set_stream_id(streams[0]->label());
     }
     const TrackInfo* track_info = FindTrackInfo(
         local_video_tracks_, new_sender->internal()->stream_id(), track->id());
     if (track_info) {
       new_sender->internal()->SetSsrc(track_info->ssrc);
     }
   } else {
     LOG(LS_ERROR) << "CreateSender called with invalid kind: " << track->kind();
@@ skipping 46 matching lines @@
     const std::string& kind,
     const std::string& stream_id) {
   TRACE_EVENT0("webrtc", "PeerConnection::CreateSender");
   if (IsClosed()) {
     return nullptr;
   }
   rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> new_sender;
   if (kind == MediaStreamTrackInterface::kAudioKind) {
     new_sender = RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
         signaling_thread(),
-        new AudioRtpSender(session_->voice_channel(), stats_.get()));
+        new rtc::RefCountedObject<AudioRtpSender>(
+            session_->voice_channel(), stats_.get()));
   } else if (kind == MediaStreamTrackInterface::kVideoKind) {
     new_sender = RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
-        signaling_thread(), new VideoRtpSender(session_->video_channel()));
+        signaling_thread(), new rtc::RefCountedObject<VideoRtpSender>(
+                                session_->video_channel()));
   } else {
     LOG(LS_ERROR) << "CreateSender called with invalid kind: " << kind;
     return new_sender;
   }
   if (!stream_id.empty()) {
     new_sender->internal()->set_stream_id(stream_id);
   }
   senders_.push_back(new_sender);
   return new_sender;
 }
@@ skipping 696 matching lines @@
       break;
   }
 }
 
 void PeerConnection::CreateAudioReceiver(MediaStreamInterface* stream,
                                          const std::string& track_id,
                                          uint32_t ssrc) {
   rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
       receiver = RtpReceiverProxyWithInternal<RtpReceiverInternal>::Create(
           signaling_thread(),
-          new AudioRtpReceiver(track_id, ssrc, session_->voice_channel()));
+          new rtc::RefCountedObject<AudioRtpReceiver>(
+              track_id, ssrc, session_->voice_channel()));
   stream->AddTrack(
       static_cast<AudioTrackInterface*>(receiver->internal()->track().get()));
   receivers_.push_back(receiver);
   std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams;
   streams.push_back(rtc::scoped_refptr<MediaStreamInterface>(stream));
   observer_->OnAddTrack(receiver, streams);
 }
 
 void PeerConnection::CreateVideoReceiver(MediaStreamInterface* stream,
                                          const std::string& track_id,
                                          uint32_t ssrc) {
   rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
       receiver = RtpReceiverProxyWithInternal<RtpReceiverInternal>::Create(
           signaling_thread(),
-          new VideoRtpReceiver(track_id, factory_->worker_thread(), ssrc,
-                               session_->video_channel()));
+          new rtc::RefCountedObject<VideoRtpReceiver>(
+              track_id, factory_->worker_thread(), ssrc,
+              session_->video_channel()));
   stream->AddTrack(
       static_cast<VideoTrackInterface*>(receiver->internal()->track().get()));
   receivers_.push_back(receiver);
   std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams;
   streams.push_back(rtc::scoped_refptr<MediaStreamInterface>(stream));
   observer_->OnAddTrack(receiver, streams);
 }
 
 // TODO(deadbeef): Keep RtpReceivers around even if track goes away in remote
 // description.
@@ skipping 16 matching lines @@
     // We already have a sender for this track, so just change the stream_id
     // so that it's correct in the next call to CreateOffer.
     (*sender)->internal()->set_stream_id(stream->label());
     return;
   }
 
   // Normal case; we've never seen this track before.
   rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> new_sender =
       RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
           signaling_thread(),
-          new AudioRtpSender(track, {stream->label()},
-                             session_->voice_channel(), stats_.get()));
+          new rtc::RefCountedObject<AudioRtpSender>(
+              track, std::vector<std::string>({stream->label()}),
+              session_->voice_channel(), stats_.get()));
   senders_.push_back(new_sender);
   // If the sender has already been configured in SDP, we call SetSsrc,
   // which will connect the sender to the underlying transport. This can
   // occur if a local session description that contains the ID of the sender
   // is set before AddStream is called. It can also occur if the local
   // session description is not changed and RemoveStream is called, and
   // later AddStream is called again with the same stream.
   const TrackInfo* track_info =
       FindTrackInfo(local_audio_tracks_, stream->label(), track->id());
   if (track_info) {
@@ skipping 23 matching lines @@
   if (sender != senders_.end()) {
     // We already have a sender for this track, so just change the stream_id
     // so that it's correct in the next call to CreateOffer.
     (*sender)->internal()->set_stream_id(stream->label());
     return;
   }
 
   // Normal case; we've never seen this track before.
   rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> new_sender =
       RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
-          signaling_thread(), new VideoRtpSender(track, {stream->label()},
-                                                 session_->video_channel()));
+          signaling_thread(), new rtc::RefCountedObject<VideoRtpSender>(
+                                  track,
+                                  std::vector<std::string>({stream->label()}),
+                                  session_->video_channel()));
   senders_.push_back(new_sender);
   const TrackInfo* track_info =
       FindTrackInfo(local_video_tracks_, stream->label(), track->id());
   if (track_info) {
     new_sender->internal()->SetSsrc(track_info->ssrc);
   }
 }
 
 void PeerConnection::RemoveVideoTrack(VideoTrackInterface* track,
                                       MediaStreamInterface* stream) {
@@ skipping 991 matching lines @@
   return event_log_->StartLogging(file, max_size_bytes);
 }
 
 void PeerConnection::StopRtcEventLog_w() {
   if (event_log_) {
     event_log_->StopLogging();
   }
 }
 
 }  // namespace webrtc