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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
// Copyright 2011 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 CC_SCHEDULER_SCHEDULER_H_
#define CC_SCHEDULER_SCHEDULER_H_
#include <deque>
#include <string>
#include "base/basictypes.h"
#include "base/cancelable_callback.h"
#include "base/memory/scoped_ptr.h"
#include "base/time/time.h"
#include "cc/base/cc_export.h"
#include "cc/output/begin_frame_args.h"
#include "cc/scheduler/delay_based_time_source.h"
#include "cc/scheduler/draw_result.h"
#include "cc/scheduler/scheduler_settings.h"
#include "cc/scheduler/scheduler_state_machine.h"
namespace base {
class SingleThreadTaskRunner;
}
namespace cc {
class SchedulerClient {
public:
virtual void SetNeedsBeginFrame(bool enable) = 0;
virtual void WillBeginImplFrame(const BeginFrameArgs& args) = 0;
virtual void ScheduledActionSendBeginMainFrame() = 0;
virtual DrawResult ScheduledActionDrawAndSwapIfPossible() = 0;
virtual DrawResult ScheduledActionDrawAndSwapForced() = 0;
virtual void ScheduledActionAnimate() = 0;
virtual void ScheduledActionCommit() = 0;
virtual void ScheduledActionUpdateVisibleTiles() = 0;
virtual void ScheduledActionActivatePendingTree() = 0;
virtual void ScheduledActionBeginOutputSurfaceCreation() = 0;
virtual void ScheduledActionManageTiles() = 0;
virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) = 0;
virtual base::TimeDelta DrawDurationEstimate() = 0;
virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() = 0;
virtual base::TimeDelta CommitToActivateDurationEstimate() = 0;
virtual void DidBeginImplFrameDeadline() = 0;
protected:
virtual ~SchedulerClient() {}
};
class CC_EXPORT Scheduler {
public:
static scoped_ptr<Scheduler> Create(
SchedulerClient* client,
const SchedulerSettings& scheduler_settings,
int layer_tree_host_id,
const scoped_refptr<base::SingleThreadTaskRunner>& impl_task_runner) {
return make_scoped_ptr(new Scheduler(
client, scheduler_settings, layer_tree_host_id, impl_task_runner));
}
virtual ~Scheduler();
const SchedulerSettings& settings() const { return settings_; }
void CommitVSyncParameters(base::TimeTicks timebase,
base::TimeDelta interval);
void SetEstimatedParentDrawTime(base::TimeDelta draw_time);
void SetCanStart();
void SetVisible(bool visible);
void SetCanDraw(bool can_draw);
void NotifyReadyToActivate();
void SetNeedsCommit();
void SetNeedsRedraw();
void SetNeedsAnimate();
void SetNeedsManageTiles();
void SetMaxSwapsPending(int max);
void DidSwapBuffers();
void SetSwapUsedIncompleteTile(bool used_incomplete_tile);
void DidSwapBuffersComplete();
void SetSmoothnessTakesPriority(bool smoothness_takes_priority);
void NotifyReadyToCommit();
void BeginMainFrameAborted(bool did_handle);
void DidManageTiles();
void DidLoseOutputSurface();
void DidCreateAndInitializeOutputSurface();
bool CommitPending() const { return state_machine_.CommitPending(); }
bool RedrawPending() const { return state_machine_.RedrawPending(); }
bool ManageTilesPending() const {
return state_machine_.ManageTilesPending();
}
bool MainThreadIsInHighLatencyMode() const {
return state_machine_.MainThreadIsInHighLatencyMode();
}
bool BeginImplFrameDeadlinePending() const {
return !begin_impl_frame_deadline_task_.IsCancelled();
}
bool WillDrawIfNeeded() const;
base::TimeTicks AnticipatedDrawTime() const;
void NotifyBeginMainFrameStarted();
base::TimeTicks LastBeginImplFrameTime();
base::TimeDelta VSyncInterval() { return vsync_interval_; }
base::TimeDelta EstimatedParentDrawTime() {
return estimated_parent_draw_time_;
}
void BeginFrame(const BeginFrameArgs& args);
void PostBeginRetroFrame();
void BeginRetroFrame();
void BeginUnthrottledFrame();
void BeginImplFrame(const BeginFrameArgs& args);
void OnBeginImplFrameDeadline();
void PollForAnticipatedDrawTriggers();
void PollToAdvanceCommitState();
scoped_ptr<base::Value> AsValue() const;
bool IsInsideAction(SchedulerStateMachine::Action action) {
return inside_action_ == action;
}
bool IsBeginMainFrameSent() const;
void SetContinuousPainting(bool continuous_painting) {
state_machine_.SetContinuousPainting(continuous_painting);
}
protected:
class CC_EXPORT SyntheticBeginFrameSource : public TimeSourceClient {
public:
SyntheticBeginFrameSource(Scheduler* scheduler,
base::SingleThreadTaskRunner* task_runner);
virtual ~SyntheticBeginFrameSource();
// Updates the phase and frequency of the timer.
void CommitVSyncParameters(base::TimeTicks timebase,
base::TimeDelta interval);
// Activates future BeginFrames and, if activating, pushes the most
// recently missed BeginFrame to the back of a retroactive queue.
void SetNeedsBeginFrame(bool needs_begin_frame,
std::deque<BeginFrameArgs>* begin_retro_frame_args);
bool IsActive() const;
// TimeSourceClient implementation of OnTimerTick triggers a BeginFrame.
virtual void OnTimerTick() OVERRIDE;
scoped_ptr<base::Value> AsValue() const;
private:
BeginFrameArgs CreateSyntheticBeginFrameArgs(base::TimeTicks frame_time);
Scheduler* scheduler_;
scoped_refptr<DelayBasedTimeSource> time_source_;
};
Scheduler(
SchedulerClient* client,
const SchedulerSettings& scheduler_settings,
int layer_tree_host_id,
const scoped_refptr<base::SingleThreadTaskRunner>& impl_task_runner);
const SchedulerSettings settings_;
SchedulerClient* client_;
int layer_tree_host_id_;
scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner_;
base::TimeDelta vsync_interval_;
base::TimeDelta estimated_parent_draw_time_;
bool last_set_needs_begin_frame_;
bool begin_unthrottled_frame_posted_;
bool begin_retro_frame_posted_;
std::deque<BeginFrameArgs> begin_retro_frame_args_;
BeginFrameArgs begin_impl_frame_args_;
scoped_ptr<SyntheticBeginFrameSource> synthetic_begin_frame_source_;
base::Closure begin_retro_frame_closure_;
base::Closure begin_unthrottled_frame_closure_;
base::Closure begin_impl_frame_deadline_closure_;
base::Closure poll_for_draw_triggers_closure_;
base::Closure advance_commit_state_closure_;
base::CancelableClosure begin_impl_frame_deadline_task_;
base::CancelableClosure poll_for_draw_triggers_task_;
base::CancelableClosure advance_commit_state_task_;
SchedulerStateMachine state_machine_;
bool inside_process_scheduled_actions_;
SchedulerStateMachine::Action inside_action_;
private:
base::TimeTicks AdjustedBeginImplFrameDeadline(
const BeginFrameArgs& args,
base::TimeDelta draw_duration_estimate) const;
void ScheduleBeginImplFrameDeadline(base::TimeTicks deadline);
void SetupNextBeginFrameIfNeeded();
void PostBeginRetroFrameIfNeeded();
void SetupNextBeginFrameWhenVSyncThrottlingEnabled(bool needs_begin_frame);
void SetupNextBeginFrameWhenVSyncThrottlingDisabled(bool needs_begin_frame);
void SetupPollingMechanisms(bool needs_begin_frame);
void DrawAndSwapIfPossible();
void ProcessScheduledActions();
bool CanCommitAndActivateBeforeDeadline() const;
void AdvanceCommitStateIfPossible();
bool IsBeginMainFrameSentOrStarted() const;
void SetupSyntheticBeginFrames();
base::WeakPtrFactory<Scheduler> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(Scheduler);
};
} // namespace cc
#endif // CC_SCHEDULER_SCHEDULER_H_
|
