File: metrics_scheduler.h

package info (click to toggle)
chromium 138.0.7204.157-1
  • links: PTS, VCS
  • area: main
  • in suites: trixie
  • size: 6,071,864 kB
  • sloc: cpp: 34,936,859; ansic: 7,176,967; javascript: 4,110,704; python: 1,419,953; asm: 946,768; xml: 739,967; pascal: 187,324; sh: 89,623; perl: 88,663; objc: 79,944; sql: 50,304; cs: 41,786; fortran: 24,137; makefile: 21,806; php: 13,980; tcl: 13,166; yacc: 8,925; ruby: 7,485; awk: 3,720; lisp: 3,096; lex: 1,327; ada: 727; jsp: 228; sed: 36
file content (80 lines) | stat: -rw-r--r-- 2,600 bytes parent folder | download | duplicates (3)
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
// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef COMPONENTS_METRICS_METRICS_SCHEDULER_H_
#define COMPONENTS_METRICS_METRICS_SCHEDULER_H_

#include "base/functional/callback.h"
#include "base/time/time.h"
#include "base/timer/timer.h"

namespace metrics {

// Scheduler task to drive a MetricsService object's uploading.
class MetricsScheduler {
 public:
  // Creates MetricsScheduler object with the given |task_callback|
  // callback to call when a task should happen.
  MetricsScheduler(const base::RepeatingClosure& task_callback,
                   bool fast_startup);

  MetricsScheduler(const MetricsScheduler&) = delete;
  MetricsScheduler& operator=(const MetricsScheduler&) = delete;

  virtual ~MetricsScheduler();

  // Starts scheduling uploads. This in a no-op if the scheduler is already
  // running, so it is safe to call more than once.
  void Start();

  // Stops scheduling uploads.
  void Stop();

  // Whether the scheduler is running.
  bool IsRunning() { return running_; }

  // Returns the initial delay before the task is run for the first time.
  static int GetInitialIntervalSeconds();

 protected:
  // Subclasses should provide task_callback with a wrapper to call this with.
  // This indicates the triggered task was completed/cancelled and the next
  // call can be scheduled.
  void TaskDone(base::TimeDelta next_interval);

  // Called by the Timer when it's time to run the task.
  virtual void TriggerTask();

  // Whether a callback is currently pending (i.e. TriggerTask() was run, but
  // not its matching TaskDone()).
  bool IsCallbackPending() { return callback_pending_; }

  // Sets `interval_`.
  void SetInterval(base::TimeDelta interval) { interval_ = interval; }

 private:
  // Schedules a future call to TriggerTask if one isn't already pending.
  void ScheduleNextTask();

  // The method to call when task should happen.
  const base::RepeatingClosure task_callback_;

  // Uses a one-shot timer rather than a repeating one because the task may be
  // async, and the length of the interval may change.
  base::OneShotTimer timer_;

  // The interval between being told an task is done and starting the next task.
  base::TimeDelta interval_;

  // Indicates that the scheduler is running (i.e., that Start has been called
  // more recently than Stop).
  bool running_;

  // Indicates that the last triggered task hasn't resolved yet.
  bool callback_pending_;
};

}  // namespace metrics

#endif  // COMPONENTS_METRICS_METRICS_SCHEDULER_H_