1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82


gpu / command_buffer / service / retaining_one_shot_timer_holder.cc [blame]

// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "gpu/command_buffer/service/retaining_one_shot_timer_holder.h"

#include "base/check.h"
#include "base/functional/bind.h"
#include "base/task/single_thread_task_runner.h"

namespace gpu {

RetainingOneShotTimerHolder::RetainingOneShotTimerHolder(
    base::TimeDelta max_delay,
    base::TimeDelta min_delay,
    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
    base::RepeatingClosure user_task)
    : min_delay_(min_delay),
      task_runner_(std::move(task_runner)),
      user_task_(std::move(user_task)),
      timer_(std::make_unique<base::RetainingOneShotTimer>(
          FROM_HERE,
          max_delay,
          base::BindRepeating(&RetainingOneShotTimerHolder::OnTimerFired,
                              base::RetainedRef(this)))) {}

void RetainingOneShotTimerHolder::ResetTimerIfNecessary() {
  if (!task_runner_->BelongsToCurrentThread()) {
    task_runner_->PostTask(
        FROM_HERE,
        base::BindOnce(&RetainingOneShotTimerHolder::ResetTimerIfNecessary,
                       base::RetainedRef(this)));
    return;
  }

  if (timer_ &&
      (!timer_->IsRunning() ||
       timer_->desired_run_time() - base::TimeTicks::Now() < min_delay_)) {
    timer_->Reset();
  }
}

void RetainingOneShotTimerHolder::DestroyTimer() {
  {
    base::AutoLock auto_lock(lock_);
    user_task_.Reset();
  }

  if (task_runner_->BelongsToCurrentThread()) {
    DestroyTimerOnTaskRunner();
    return;
  }

  task_runner_->PostTask(
      FROM_HERE,
      base::BindOnce(&RetainingOneShotTimerHolder::DestroyTimerOnTaskRunner,
                     base::RetainedRef(this)));
}

RetainingOneShotTimerHolder::~RetainingOneShotTimerHolder() {
  // DestroyTimer() must have been called to clean up.
  CHECK(user_task_.is_null());
}

void RetainingOneShotTimerHolder::DestroyTimerOnTaskRunner() {
  timer_ = nullptr;
}

void RetainingOneShotTimerHolder::OnTimerFired() {
  base::AutoLock auto_lock(lock_);
  if (user_task_.is_null()) {
    return;
  }

  // Note: `user_task_` is run while holding `lock_` in order to guarantee that
  // once DestroyTimer() returns, `user_task_` definitely won't be called
  // afterwards. Please also see the comment of constructor and DestroyTimer()
  // for more details.
  user_task_.Run();
}

}  // namespace gpu