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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef WebTaskRunner_h
#define WebTaskRunner_h
#include "base/callback_forward.h"
#include "public/platform/WebCommon.h"
#include "public/platform/WebTraceLocation.h"
#include "wtf/Compiler.h"
#include "wtf/Functional.h"
#include "wtf/RefCounted.h"
#include "wtf/WeakPtr.h"
#include <memory>
namespace base {
class SingleThreadTaskRunner;
}
namespace blink {
using SingleThreadTaskRunner = base::SingleThreadTaskRunner;
// TaskHandle is associated to a task posted by
// WebTaskRunner::postCancellableTask or
// WebTaskRunner::postCancellableDelayedTask and cancels the associated task on
// TaskHandle::cancel() call or on TaskHandle destruction.
class BLINK_PLATFORM_EXPORT TaskHandle {
public:
// Returns true if the task will run later. Returns false if the task is
// cancelled or the task is run already.
// This function is not thread safe. Call this on the thread that has posted
// the task.
bool isActive() const;
// Cancels the task invocation. Do nothing if the task is cancelled or run
// already.
// This function is not thread safe. Call this on the thread that has posted
// the task.
void cancel();
TaskHandle();
~TaskHandle();
TaskHandle(TaskHandle&&);
TaskHandle& operator=(TaskHandle&&);
class Runner;
private:
friend class WebTaskRunner;
explicit TaskHandle(RefPtr<Runner>);
RefPtr<Runner> m_runner;
};
// The blink representation of a chromium SingleThreadTaskRunner.
class BLINK_PLATFORM_EXPORT WebTaskRunner
: public ThreadSafeRefCounted<WebTaskRunner> {
public:
// Schedule a task to be run after |delayMs| on the the associated WebThread.
// Can be called from any thread.
virtual void postDelayedTask(const WebTraceLocation&,
const base::Closure&,
double delayMs) = 0;
// Returns true if the current thread is a thread on which a task may be run.
// Can be called from any thread.
virtual bool runsTasksOnCurrentThread() = 0;
// ---
// Headless Chrome virtualises time for determinism and performance (fast
// forwarding of timers). To make this work some parts of blink (e.g. Timers)
// need to use virtual time, however by default new code should use the normal
// non-virtual time APIs.
// Returns a double which is the number of seconds since epoch (Jan 1, 1970).
// This may represent either the real time, or a virtual time depending on
// whether or not the WebTaskRunner is associated with a virtual time domain
// or a real time domain.
virtual double virtualTimeSeconds() const = 0;
// Returns a microsecond resolution platform dependant time source.
// This may represent either the real time, or a virtual time depending on
// whether or not the WebTaskRunner is associated with a virtual time domain
// or a real time domain.
virtual double monotonicallyIncreasingVirtualTimeSeconds() const = 0;
// Returns the underlying task runner object.
virtual SingleThreadTaskRunner* toSingleThreadTaskRunner() = 0;
// Helpers for posting bound functions as tasks.
// For cross-thread posting. Can be called from any thread.
void postTask(const WebTraceLocation&, std::unique_ptr<CrossThreadClosure>);
void postDelayedTask(const WebTraceLocation&,
std::unique_ptr<CrossThreadClosure>,
long long delayMs);
// For same-thread posting. Must be called from the associated WebThread.
void postTask(const WebTraceLocation&, std::unique_ptr<WTF::Closure>);
void postDelayedTask(const WebTraceLocation&,
std::unique_ptr<WTF::Closure>,
long long delayMs);
// For same-thread cancellable task posting. Returns a TaskHandle object for
// cancellation.
WARN_UNUSED_RESULT TaskHandle
postCancellableTask(const WebTraceLocation&, std::unique_ptr<WTF::Closure>);
WARN_UNUSED_RESULT TaskHandle
postDelayedCancellableTask(const WebTraceLocation&,
std::unique_ptr<WTF::Closure>,
long long delayMs);
protected:
friend ThreadSafeRefCounted<WebTaskRunner>;
WebTaskRunner() = default;
virtual ~WebTaskRunner();
private:
DISALLOW_COPY_AND_ASSIGN(WebTaskRunner);
};
} // namespace blink
#endif // WebTaskRunner_h
|
