Add support for WeakPtr<T>

webrtc/video/video_send_stream.cc

 /*
  *  Copyright (c) 2013 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.
  */
 #include "webrtc/video/video_send_stream.h"
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "webrtc/common_types.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/file.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
+#include "webrtc/base/weak_ptr.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/congestion_controller/include/congestion_controller.h"
 #include "webrtc/modules/pacing/packet_router.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/modules/video_coding/utility/ivf_file_writer.h"
 #include "webrtc/video/call_stats.h"
 #include "webrtc/video/vie_remb.h"
 #include "webrtc/video_send_stream.h"
 
@@ skipping 299 matching lines @@
   uint32_t encoder_target_rate_bps_;
 
   ViEEncoder* const vie_encoder_;
   EncoderStateFeedback encoder_feedback_;
   ProtectionBitrateCalculator protection_bitrate_calculator_;
 
   const std::unique_ptr<RtcpBandwidthObserver> bandwidth_observer_;
   // RtpRtcp modules, declared here as they use other members on construction.
   const std::vector<RtpRtcp*> rtp_rtcp_modules_;
   PayloadRouter payload_router_;
+
+  // |weak_ptr_| to our self. This is used since we can not call
+  // |weak_ptr_factory_.GetWeakPtr| from multiple sequences but it is ok to copy
+  // an existing WeakPtr.
+  rtc::WeakPtr<VideoSendStreamImpl> weak_ptr_;
+  // |weak_ptr_factory_| must be declared last to make sure all WeakPtr's are
+  // invalidated before any other members are destroyed.
+  rtc::WeakPtrFactory<VideoSendStreamImpl> weak_ptr_factory_;
 };
 
 // TODO(tommi): See if there's a more elegant way to create a task that creates
 // an object on the correct task queue.
 class VideoSendStream::ConstructionTask : public rtc::QueuedTask {
  public:
   ConstructionTask(std::unique_ptr<VideoSendStreamImpl>* send_stream,
                    rtc::Event* done_event,
                    SendStatisticsProxy* stats_proxy,
                    ViEEncoder* vie_encoder,
@@ skipping 72 matching lines @@
   std::unique_ptr<VideoSendStreamImpl> send_stream_;
   rtc::Event* done_event_;
 };
 
 // CheckEncoderActivityTask is used for tracking when the encoder last produced
 // and encoded video frame. If the encoder has not produced anything the last
 // kEncoderTimeOutMs we also want to stop sending padding.
 class VideoSendStreamImpl::CheckEncoderActivityTask : public rtc::QueuedTask {
  public:
   static const int kEncoderTimeOutMs = 2000;
-  explicit CheckEncoderActivityTask(VideoSendStreamImpl* send_stream)
-      : activity_(0), send_stream_(send_stream), timed_out_(false) {}
+  explicit CheckEncoderActivityTask(
+      const rtc::WeakPtr<VideoSendStreamImpl>& send_stream)
+      : activity_(0), send_stream_(std::move(send_stream)), timed_out_(false) {}
 
   void Stop() {
     RTC_CHECK(task_checker_.CalledSequentially());
-    send_stream_ = nullptr;
+    send_stream_.reset();
   }
 
   void UpdateEncoderActivity() {
     // UpdateEncoderActivity is called from VideoSendStreamImpl::Encoded on
     // whatever thread the real encoder implementation run on. In the case of
     // hardware encoders, there might be several encoders
     // running in parallel on different threads.
     rtc::AtomicOps::ReleaseStore(&activity_, 1);
   }
 
@@ skipping 15 matching lines @@
 
     rtc::TaskQueue::Current()->PostDelayedTask(
         std::unique_ptr<rtc::QueuedTask>(this), kEncoderTimeOutMs);
     // Return false to prevent this task from being deleted. Ownership has been
     // transferred to the task queue when PostDelayedTask was called.
     return false;
   }
   volatile int activity_;
 
   rtc::SequencedTaskChecker task_checker_;
-  VideoSendStreamImpl* send_stream_;
+  rtc::WeakPtr<VideoSendStreamImpl> send_stream_;
   bool timed_out_;
 };
 
 class VideoSendStreamImpl::EncoderReconfiguredTask : public rtc::QueuedTask {
  public:
-  EncoderReconfiguredTask(VideoSendStreamImpl* send_stream,
+  EncoderReconfiguredTask(const rtc::WeakPtr<VideoSendStreamImpl>& send_stream,
                           std::vector<VideoStream> streams,
                           int min_transmit_bitrate_bps)
-      : send_stream_(send_stream),
+      : send_stream_(std::move(send_stream)),
         streams_(std::move(streams)),
         min_transmit_bitrate_bps_(min_transmit_bitrate_bps) {}
 
  private:
   bool Run() override {
-    send_stream_->OnEncoderConfigurationChanged(std::move(streams_),
-                                                min_transmit_bitrate_bps_);
+    if (send_stream_)
+      send_stream_->OnEncoderConfigurationChanged(std::move(streams_),
+                                                  min_transmit_bitrate_bps_);
     return true;
   }
 
-  VideoSendStreamImpl* send_stream_;
+  rtc::WeakPtr<VideoSendStreamImpl> send_stream_;
   std::vector<VideoStream> streams_;
   int min_transmit_bitrate_bps_;
 };
 
 VideoSendStream::VideoSendStream(
     int num_cpu_cores,
     ProcessThread* module_process_thread,
     rtc::TaskQueue* worker_queue,
     CallStats* call_stats,
     CongestionController* congestion_controller,
@@ skipping 162 matching lines @@
           congestion_controller_->GetTransportFeedbackObserver(),
           call_stats_->rtcp_rtt_stats(),
           congestion_controller_->pacer(),
           congestion_controller_->packet_router(),
           stats_proxy_,
           send_delay_stats,
           event_log,
           congestion_controller_->GetRetransmissionRateLimiter(),
           config_->rtp.ssrcs.size())),
       payload_router_(rtp_rtcp_modules_,
-                      config_->encoder_settings.payload_type) {
+                      config_->encoder_settings.payload_type),
+      weak_ptr_factory_(this) {
   RTC_DCHECK_RUN_ON(worker_queue_);
   LOG(LS_INFO) << "VideoSendStreamInternal: " << config_->ToString();
+  weak_ptr_ = weak_ptr_factory_.GetWeakPtr();
   module_process_thread_checker_.DetachFromThread();
 
   RTC_DCHECK(!config_->rtp.ssrcs.empty());
   RTC_DCHECK(call_stats_);
   RTC_DCHECK(congestion_controller_);
   RTC_DCHECK(remb_);
 
   // RTP/RTCP initialization.
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     congestion_controller_->packet_router()->AddRtpModule(rtp_rtcp);
@@ skipping 90 matching lines @@
   payload_router_.set_active(true);
 
   bitrate_allocator_->AddObserver(
       this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_,
       max_padding_bitrate_, !config_->suspend_below_min_bitrate);
 
   // Start monitoring encoder activity.
   {
     rtc::CritScope lock(&encoder_activity_crit_sect_);
     RTC_DCHECK(!check_encoder_activity_task_);
-    check_encoder_activity_task_ = new CheckEncoderActivityTask(this);
+    check_encoder_activity_task_ = new CheckEncoderActivityTask(weak_ptr_);
     worker_queue_->PostDelayedTask(
         std::unique_ptr<rtc::QueuedTask>(check_encoder_activity_task_),
         CheckEncoderActivityTask::kEncoderTimeOutMs);
   }
 
   vie_encoder_->SendKeyFrame();
 }
 
 void VideoSendStreamImpl::Stop() {
   RTC_DCHECK_RUN_ON(worker_queue_);
@@ skipping 28 matching lines @@
   LOG(LS_INFO) << "SignalEncoderActive, Encoder is active.";
   bitrate_allocator_->AddObserver(
       this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_,
       max_padding_bitrate_, !config_->suspend_below_min_bitrate);
 }
 
 void VideoSendStreamImpl::OnEncoderConfigurationChanged(
     std::vector<VideoStream> streams,
     int min_transmit_bitrate_bps) {
   if (!worker_queue_->IsCurrent()) {
-    // TODO(perkj): Using |this| in post is safe for now since destruction of
-    // VideoSendStreamImpl is synchronized in
-    // VideoSendStream::StopPermanentlyAndGetRtpStates. But we should really
-    // use some kind of weak_ptr to guarantee that VideoSendStreamImpl is still
-    // alive when this task runs.
     worker_queue_->PostTask(
         std::unique_ptr<rtc::QueuedTask>(new EncoderReconfiguredTask(
-            this, std::move(streams), min_transmit_bitrate_bps)));
+            weak_ptr_, std::move(streams), min_transmit_bitrate_bps)));
     return;
   }
   RTC_DCHECK_GE(config_->rtp.ssrcs.size(), streams.size());
   TRACE_EVENT0("webrtc", "VideoSendStream::OnEncoderConfigurationChanged");
   RTC_DCHECK_GE(config_->rtp.ssrcs.size(), streams.size());
   RTC_DCHECK_RUN_ON(worker_queue_);
 
   const int kEncoderMinBitrateBps = 30000;
   encoder_min_bitrate_bps_ =
       std::max(streams[0].min_bitrate_bps, kEncoderMinBitrateBps);
@@ skipping 250 matching lines @@
                           &module_nack_rate);
     *sent_video_rate_bps += module_video_rate;
     *sent_nack_rate_bps += module_nack_rate;
     *sent_fec_rate_bps += module_fec_rate;
   }
   return 0;
 }
 
 }  // namespace internal
 }  // namespace webrtc