1 files changed, 36 insertions, 33 deletions

diff --git a/rtc_base/task_utils/repeating_task.h b/rtc_base/task_utils/repeating_task.h
index 487b7d19d4..d5066fdb5c 100644
--- a/rtc_base/task_utils/repeating_task.h
+++ b/rtc_base/task_utils/repeating_task.h
@@ -19,22 +19,19 @@
 #include "api/task_queue/task_queue_base.h"
 #include "api/units/time_delta.h"
 #include "api/units/timestamp.h"
+#include "rtc_base/task_utils/pending_task_safety_flag.h"
 #include "system_wrappers/include/clock.h"
 
 namespace webrtc {
-
-class RepeatingTaskHandle;
-
 namespace webrtc_repeating_task_impl {
 class RepeatingTaskBase : public QueuedTask {
  public:
   RepeatingTaskBase(TaskQueueBase* task_queue,
                     TimeDelta first_delay,
-                    Clock* clock);
+                    Clock* clock,
+                    rtc::scoped_refptr<PendingTaskSafetyFlag> alive_flag);
   ~RepeatingTaskBase() override;
 
-  void Stop();
-
  private:
   virtual TimeDelta RunClosure() = 0;
 
@@ -42,9 +39,10 @@ class RepeatingTaskBase : public QueuedTask {
 
   TaskQueueBase* const task_queue_;
   Clock* const clock_;
-  // This is always finite, except for the special case where it's PlusInfinity
-  // to signal that the task should stop.
+  // This is always finite.
   Timestamp next_run_time_ RTC_GUARDED_BY(task_queue_);
+  rtc::scoped_refptr<PendingTaskSafetyFlag> alive_flag_
+      RTC_GUARDED_BY(task_queue_);
 };
 
 // The template closure pattern is based on rtc::ClosureTask.
@@ -54,8 +52,12 @@ class RepeatingTaskImpl final : public RepeatingTaskBase {
   RepeatingTaskImpl(TaskQueueBase* task_queue,
                     TimeDelta first_delay,
                     Closure&& closure,
-                    Clock* clock)
-      : RepeatingTaskBase(task_queue, first_delay, clock),
+                    Clock* clock,
+                    rtc::scoped_refptr<PendingTaskSafetyFlag> alive_flag)
+      : RepeatingTaskBase(task_queue,
+                          first_delay,
+                          clock,
+                          std::move(alive_flag)),
         closure_(std::forward<Closure>(closure)) {
     static_assert(
         std::is_same<TimeDelta,
@@ -81,28 +83,27 @@ class RepeatingTaskHandle {
  public:
   RepeatingTaskHandle() = default;
   ~RepeatingTaskHandle() = default;
-  RepeatingTaskHandle(RepeatingTaskHandle&& other);
-  RepeatingTaskHandle& operator=(RepeatingTaskHandle&& other);
+  RepeatingTaskHandle(RepeatingTaskHandle&& other) = default;
+  RepeatingTaskHandle& operator=(RepeatingTaskHandle&& other) = default;
   RepeatingTaskHandle(const RepeatingTaskHandle&) = delete;
   RepeatingTaskHandle& operator=(const RepeatingTaskHandle&) = delete;
 
   // Start can be used to start a task that will be reposted with a delay
   // determined by the return value of the provided closure. The actual task is
   // owned by the TaskQueue and will live until it has been stopped or the
-  // TaskQueue is destroyed. Note that this means that trying to stop the
-  // repeating task after the TaskQueue is destroyed is an error. However, it's
-  // perfectly fine to destroy the handle while the task is running, since the
-  // repeated task is owned by the TaskQueue.
+  // TaskQueue deletes it. It's perfectly fine to destroy the handle while the
+  // task is running, since the repeated task is owned by the TaskQueue.
   template <class Closure>
   static RepeatingTaskHandle Start(TaskQueueBase* task_queue,
                                    Closure&& closure,
                                    Clock* clock = Clock::GetRealTimeClock()) {
-    auto repeating_task = std::make_unique<
-        webrtc_repeating_task_impl::RepeatingTaskImpl<Closure>>(
-        task_queue, TimeDelta::Zero(), std::forward<Closure>(closure), clock);
-    auto* repeating_task_ptr = repeating_task.get();
-    task_queue->PostTask(std::move(repeating_task));
-    return RepeatingTaskHandle(repeating_task_ptr);
+    auto alive_flag = PendingTaskSafetyFlag::CreateDetached();
+    task_queue->PostTask(
+        std::make_unique<
+            webrtc_repeating_task_impl::RepeatingTaskImpl<Closure>>(
+            task_queue, TimeDelta::Zero(), std::forward<Closure>(closure),
+            clock, alive_flag));
+    return RepeatingTaskHandle(std::move(alive_flag));
   }
 
   // DelayedStart is equivalent to Start except that the first invocation of the
@@ -113,12 +114,14 @@ class RepeatingTaskHandle {
       TimeDelta first_delay,
       Closure&& closure,
       Clock* clock = Clock::GetRealTimeClock()) {
-    auto repeating_task = std::make_unique<
-        webrtc_repeating_task_impl::RepeatingTaskImpl<Closure>>(
-        task_queue, first_delay, std::forward<Closure>(closure), clock);
-    auto* repeating_task_ptr = repeating_task.get();
-    task_queue->PostDelayedTask(std::move(repeating_task), first_delay.ms());
-    return RepeatingTaskHandle(repeating_task_ptr);
+    auto alive_flag = PendingTaskSafetyFlag::CreateDetached();
+    task_queue->PostDelayedTask(
+        std::make_unique<
+            webrtc_repeating_task_impl::RepeatingTaskImpl<Closure>>(
+            task_queue, first_delay, std::forward<Closure>(closure), clock,
+            alive_flag),
+        first_delay.ms());
+    return RepeatingTaskHandle(std::move(alive_flag));
   }
 
   // Stops future invocations of the repeating task closure. Can only be called
@@ -127,15 +130,15 @@ class RepeatingTaskHandle {
   // closure itself.
   void Stop();
 
-  // Returns true if Start() or DelayedStart() was called most recently. Returns
-  // false initially and if Stop() or PostStop() was called most recently.
+  // Returns true until Stop() was called.
+  // Can only be called from the TaskQueue where the task is running.
   bool Running() const;
 
  private:
   explicit RepeatingTaskHandle(
-      webrtc_repeating_task_impl::RepeatingTaskBase* repeating_task);
-  // Owned by the task queue.
-  webrtc_repeating_task_impl::RepeatingTaskBase* repeating_task_ = nullptr;
+      rtc::scoped_refptr<PendingTaskSafetyFlag> alive_flag)
+      : repeating_task_(std::move(alive_flag)) {}
+  rtc::scoped_refptr<PendingTaskSafetyFlag> repeating_task_;
 };
 
 }  // namespace webrtc