Repo created

TMessagesProj/jni/voip/webrtc/rtc_base/task_utils/repeating_task.cc

@@ -0,0 +1,140 @@
+/*
+ *  Copyright 2019 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 "rtc_base/task_utils/repeating_task.h"
+
+#include "absl/functional/any_invocable.h"
+#include "api/task_queue/pending_task_safety_flag.h"
+#include "rtc_base/logging.h"
+
+namespace webrtc {
+namespace {
+
+class RepeatingTask {
+ public:
+  RepeatingTask(TaskQueueBase* task_queue,
+                TaskQueueBase::DelayPrecision precision,
+                TimeDelta first_delay,
+                absl::AnyInvocable<TimeDelta()> task,
+                Clock* clock,
+                rtc::scoped_refptr<PendingTaskSafetyFlag> alive_flag,
+                const Location& location);
+  RepeatingTask(RepeatingTask&&) = default;
+  RepeatingTask& operator=(RepeatingTask&&) = delete;
+  ~RepeatingTask() = default;
+
+  void operator()() &&;
+
+ private:
+  TaskQueueBase* const task_queue_;
+  const TaskQueueBase::DelayPrecision precision_;
+  Clock* const clock_;
+  const Location location_;
+  absl::AnyInvocable<TimeDelta()> task_;
+  // This is always finite.
+  Timestamp next_run_time_ RTC_GUARDED_BY(task_queue_);
+  rtc::scoped_refptr<PendingTaskSafetyFlag> alive_flag_
+      RTC_GUARDED_BY(task_queue_);
+};
+
+RepeatingTask::RepeatingTask(
+    TaskQueueBase* task_queue,
+    TaskQueueBase::DelayPrecision precision,
+    TimeDelta first_delay,
+    absl::AnyInvocable<TimeDelta()> task,
+    Clock* clock,
+    rtc::scoped_refptr<PendingTaskSafetyFlag> alive_flag,
+    const Location& location)
+    : task_queue_(task_queue),
+      precision_(precision),
+      clock_(clock),
+      location_(location),
+      task_(std::move(task)),
+      next_run_time_(clock_->CurrentTime() + first_delay),
+      alive_flag_(std::move(alive_flag)) {}
+
+void RepeatingTask::operator()() && {
+  RTC_DCHECK_RUN_ON(task_queue_);
+  if (!alive_flag_->alive())
+    return;
+
+  webrtc_repeating_task_impl::RepeatingTaskImplDTraceProbeRun();
+  TimeDelta delay = task_();
+  RTC_DCHECK_GE(delay, TimeDelta::Zero());
+
+  // A delay of +infinity means that the task should not be run again.
+  // Alternatively, the closure might have stopped this task.
+  if (delay.IsPlusInfinity() || !alive_flag_->alive())
+    return;
+
+  TimeDelta lost_time = clock_->CurrentTime() - next_run_time_;
+  next_run_time_ += delay;
+  delay -= lost_time;
+  delay = std::max(delay, TimeDelta::Zero());
+
+  task_queue_->PostDelayedTaskWithPrecision(precision_, std::move(*this), delay,
+                                            location_);
+}
+
+}  // namespace
+
+RepeatingTaskHandle RepeatingTaskHandle::Start(
+    TaskQueueBase* task_queue,
+    absl::AnyInvocable<TimeDelta()> closure,
+    TaskQueueBase::DelayPrecision precision,
+    Clock* clock,
+    const Location& location) {
+  auto alive_flag = PendingTaskSafetyFlag::CreateDetached();
+  webrtc_repeating_task_impl::RepeatingTaskHandleDTraceProbeStart();
+  task_queue->PostTask(
+      RepeatingTask(task_queue, precision, TimeDelta::Zero(),
+                    std::move(closure), clock, alive_flag, location),
+      location);
+  return RepeatingTaskHandle(std::move(alive_flag));
+}
+
+// DelayedStart is equivalent to Start except that the first invocation of the
+// closure will be delayed by the given amount.
+RepeatingTaskHandle RepeatingTaskHandle::DelayedStart(
+    TaskQueueBase* task_queue,
+    TimeDelta first_delay,
+    absl::AnyInvocable<TimeDelta()> closure,
+    TaskQueueBase::DelayPrecision precision,
+    Clock* clock,
+    const Location& location) {
+  auto alive_flag = PendingTaskSafetyFlag::CreateDetached();
+  webrtc_repeating_task_impl::RepeatingTaskHandleDTraceProbeDelayedStart();
+  task_queue->PostDelayedTaskWithPrecision(
+      precision,
+      RepeatingTask(task_queue, precision, first_delay, std::move(closure),
+                    clock, alive_flag, location),
+      first_delay, location);
+  return RepeatingTaskHandle(std::move(alive_flag));
+}
+
+void RepeatingTaskHandle::Stop() {
+  if (repeating_task_) {
+    repeating_task_->SetNotAlive();
+    repeating_task_ = nullptr;
+  }
+}
+
+bool RepeatingTaskHandle::Running() const {
+  return repeating_task_ != nullptr;
+}
+
+namespace webrtc_repeating_task_impl {
+// These methods are empty, but can be externally equipped with actions using
+// dtrace.
+void RepeatingTaskHandleDTraceProbeStart() {}
+void RepeatingTaskHandleDTraceProbeDelayedStart() {}
+void RepeatingTaskImplDTraceProbeRun() {}
+}  // namespace webrtc_repeating_task_impl
+}  // namespace webrtc

TMessagesProj/jni/voip/webrtc/rtc_base/task_utils/repeating_task.h

@@ -0,0 +1,92 @@
+/*
+ *  Copyright 2019 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.
+ */
+
+#ifndef RTC_BASE_TASK_UTILS_REPEATING_TASK_H_
+#define RTC_BASE_TASK_UTILS_REPEATING_TASK_H_
+
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include "absl/functional/any_invocable.h"
+#include "api/task_queue/pending_task_safety_flag.h"
+#include "api/task_queue/task_queue_base.h"
+#include "api/units/time_delta.h"
+#include "system_wrappers/include/clock.h"
+
+namespace webrtc {
+
+namespace webrtc_repeating_task_impl {
+
+// Methods simplifying external tracing of RepeatingTaskHandle operations.
+void RepeatingTaskHandleDTraceProbeStart();
+void RepeatingTaskHandleDTraceProbeDelayedStart();
+void RepeatingTaskImplDTraceProbeRun();
+
+}  // namespace webrtc_repeating_task_impl
+
+// Allows starting tasks that repeat themselves on a TaskQueue indefinately
+// until they are stopped or the TaskQueue is destroyed. It allows starting and
+// stopping multiple times, but you must stop one task before starting another
+// and it can only be stopped when in the running state. The public interface is
+// not thread safe.
+class RepeatingTaskHandle {
+ public:
+  RepeatingTaskHandle() = default;
+  ~RepeatingTaskHandle() = default;
+  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 deletes it. It's perfectly fine to destroy the handle while the
+  // task is running, since the repeated task is owned by the TaskQueue.
+  // The tasks are scheduled onto the task queue using the specified precision.
+  static RepeatingTaskHandle Start(
+      TaskQueueBase* task_queue,
+      absl::AnyInvocable<TimeDelta()> closure,
+      TaskQueueBase::DelayPrecision precision =
+          TaskQueueBase::DelayPrecision::kLow,
+      Clock* clock = Clock::GetRealTimeClock(),
+      const Location& location = Location::Current());
+
+  // DelayedStart is equivalent to Start except that the first invocation of the
+  // closure will be delayed by the given amount.
+  static RepeatingTaskHandle DelayedStart(
+      TaskQueueBase* task_queue,
+      TimeDelta first_delay,
+      absl::AnyInvocable<TimeDelta()> closure,
+      TaskQueueBase::DelayPrecision precision =
+          TaskQueueBase::DelayPrecision::kLow,
+      Clock* clock = Clock::GetRealTimeClock(),
+      const Location& location = Location::Current());
+
+  // Stops future invocations of the repeating task closure. Can only be called
+  // from the TaskQueue where the task is running. The closure is guaranteed to
+  // not be running after Stop() returns unless Stop() is called from the
+  // closure itself.
+  void Stop();
+
+  // Returns true until Stop() was called.
+  // Can only be called from the TaskQueue where the task is running.
+  bool Running() const;
+
+ private:
+  explicit RepeatingTaskHandle(
+      rtc::scoped_refptr<PendingTaskSafetyFlag> alive_flag)
+      : repeating_task_(std::move(alive_flag)) {}
+  rtc::scoped_refptr<PendingTaskSafetyFlag> repeating_task_;
+};
+
+}  // namespace webrtc
+#endif  // RTC_BASE_TASK_UTILS_REPEATING_TASK_H_