1 // Copyright 2015 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "cc/surfaces/display_scheduler.h"
9 #include "base/stl_util.h"
10 #include "base/trace_event/trace_event.h"
11 #include "cc/output/output_surface.h"
15 DisplayScheduler::DisplayScheduler(DisplaySchedulerClient
* client
,
16 BeginFrameSource
* begin_frame_source
,
17 base::SingleThreadTaskRunner
* task_runner
,
18 int max_pending_swaps
)
20 begin_frame_source_(begin_frame_source
),
21 task_runner_(task_runner
),
22 output_surface_lost_(false),
23 root_surface_resources_locked_(true),
24 inside_begin_frame_deadline_interval_(false),
26 entire_display_damaged_(false),
27 all_active_child_surfaces_ready_to_draw_(false),
29 max_pending_swaps_(max_pending_swaps
),
30 root_surface_damaged_(false),
31 expect_damage_from_root_surface_(false),
32 weak_ptr_factory_(this) {
33 begin_frame_source_
->AddObserver(this);
34 begin_frame_deadline_closure_
= base::Bind(
35 &DisplayScheduler::OnBeginFrameDeadline
, weak_ptr_factory_
.GetWeakPtr());
38 DisplayScheduler::~DisplayScheduler() {
39 begin_frame_source_
->RemoveObserver(this);
42 // If we try to draw when the root surface resources are locked, the
44 void DisplayScheduler::SetRootSurfaceResourcesLocked(bool locked
) {
45 root_surface_resources_locked_
= locked
;
46 ScheduleBeginFrameDeadline();
49 // This is used to force an immediate swap before a resize.
50 void DisplayScheduler::ForceImmediateSwapIfPossible() {
51 bool in_begin
= inside_begin_frame_deadline_interval_
;
54 begin_frame_source_
->DidFinishFrame(0);
57 // Notification that there was a resize or the root surface changed and
58 // that we should just draw immediately.
59 void DisplayScheduler::EntireDisplayDamaged(SurfaceId root_surface_id
) {
60 TRACE_EVENT0("cc", "DisplayScheduler::EntireDisplayDamaged");
62 entire_display_damaged_
= true;
63 root_surface_id_
= root_surface_id
;
65 begin_frame_source_
->SetNeedsBeginFrames(!output_surface_lost_
);
66 ScheduleBeginFrameDeadline();
69 // Indicates that there was damage to one of the surfaces.
70 // Has some logic to wait for multiple active surfaces before
71 // triggering the deadline.
72 void DisplayScheduler::SurfaceDamaged(SurfaceId surface_id
) {
73 TRACE_EVENT1("cc", "DisplayScheduler::SurfaceDamaged", "surface_id",
78 if (surface_id
== root_surface_id_
) {
79 root_surface_damaged_
= true;
81 child_surface_ids_damaged_
.insert(surface_id
);
83 // TODO(mithro): Use hints from SetNeedsBeginFrames and SwapAborts.
84 all_active_child_surfaces_ready_to_draw_
= base::STLIncludes(
85 child_surface_ids_damaged_
, child_surface_ids_to_expect_damage_from_
);
88 begin_frame_source_
->SetNeedsBeginFrames(!output_surface_lost_
);
89 ScheduleBeginFrameDeadline();
92 void DisplayScheduler::OutputSurfaceLost() {
93 TRACE_EVENT0("cc", "DisplayScheduler::OutputSurfaceLost");
94 output_surface_lost_
= true;
95 begin_frame_source_
->SetNeedsBeginFrames(false);
96 ScheduleBeginFrameDeadline();
99 void DisplayScheduler::DrawAndSwap() {
100 TRACE_EVENT0("cc", "DisplayScheduler::DrawAndSwap");
101 DCHECK_LT(pending_swaps_
, max_pending_swaps_
);
102 DCHECK(!output_surface_lost_
);
104 bool success
= client_
->DrawAndSwap();
108 child_surface_ids_to_expect_damage_from_
=
109 base::STLSetIntersection
<std::vector
<SurfaceId
>>(
110 child_surface_ids_damaged_
, child_surface_ids_damaged_prev_
);
112 child_surface_ids_damaged_prev_
.swap(child_surface_ids_damaged_
);
113 child_surface_ids_damaged_
.clear();
116 entire_display_damaged_
= false;
117 all_active_child_surfaces_ready_to_draw_
=
118 child_surface_ids_to_expect_damage_from_
.empty();
120 expect_damage_from_root_surface_
= root_surface_damaged_
;
121 root_surface_damaged_
= false;
124 bool DisplayScheduler::OnBeginFrameDerivedImpl(const BeginFrameArgs
& args
) {
125 base::TimeTicks now
= base::TimeTicks::Now();
126 TRACE_EVENT2("cc", "DisplayScheduler::BeginFrame", "args", args
.AsValue(),
129 // If we get another BeginFrame before the previous deadline,
130 // synchronously trigger the previous deadline before progressing.
131 if (inside_begin_frame_deadline_interval_
) {
132 OnBeginFrameDeadline();
135 // Schedule the deadline.
136 current_begin_frame_args_
= args
;
137 current_begin_frame_args_
.deadline
-=
138 BeginFrameArgs::DefaultEstimatedParentDrawTime();
139 inside_begin_frame_deadline_interval_
= true;
140 ScheduleBeginFrameDeadline();
145 base::TimeTicks
DisplayScheduler::DesiredBeginFrameDeadlineTime() {
146 if (output_surface_lost_
) {
147 TRACE_EVENT_INSTANT0("cc", "Lost output surface", TRACE_EVENT_SCOPE_THREAD
);
148 return base::TimeTicks();
151 if (pending_swaps_
>= max_pending_swaps_
) {
152 TRACE_EVENT_INSTANT0("cc", "Swap throttled", TRACE_EVENT_SCOPE_THREAD
);
153 return current_begin_frame_args_
.deadline
;
157 TRACE_EVENT_INSTANT0("cc", "No damage yet", TRACE_EVENT_SCOPE_THREAD
);
158 return current_begin_frame_args_
.frame_time
+
159 current_begin_frame_args_
.interval
;
162 if (root_surface_resources_locked_
) {
163 TRACE_EVENT_INSTANT0("cc", "Root surface resources locked",
164 TRACE_EVENT_SCOPE_THREAD
);
165 return current_begin_frame_args_
.frame_time
+
166 current_begin_frame_args_
.interval
;
169 // TODO(mithro): Be smarter about resize deadlines.
170 if (entire_display_damaged_
) {
171 TRACE_EVENT_INSTANT0("cc", "Entire display damaged",
172 TRACE_EVENT_SCOPE_THREAD
);
173 return base::TimeTicks();
176 bool root_ready_to_draw
=
177 !expect_damage_from_root_surface_
|| root_surface_damaged_
;
179 if (all_active_child_surfaces_ready_to_draw_
&& root_ready_to_draw
) {
180 TRACE_EVENT_INSTANT0("cc", "All active surfaces ready",
181 TRACE_EVENT_SCOPE_THREAD
);
182 return base::TimeTicks();
185 // Use an earlier deadline if we are only waiting for the root surface
186 // in case our expect_damage_from_root_surface heuristic is incorrect.
187 // TODO(mithro): Replace this with SetNeedsBeginFrame and SwapAbort
189 if (all_active_child_surfaces_ready_to_draw_
&&
190 expect_damage_from_root_surface_
) {
191 TRACE_EVENT_INSTANT0("cc", "Waiting for damage from root surface",
192 TRACE_EVENT_SCOPE_THREAD
);
193 // This adjusts the deadline by DefaultEstimatedParentDrawTime for
194 // a second time. The first one represented the Surfaces draw to display
195 // latency. This one represents root surface commit+raster+draw latency.
196 // We treat the root surface differently since it lives on the same thread
197 // as Surfaces and waiting for it too long may push out the Surfaces draw.
198 // If we also assume the root surface is fast to start a commit after the
199 // beginning of a frame, it'll have a chance to lock its resources, which
200 // will cause us to wait for it to unlock its resources above.
201 // TODO(mithro): Replace hard coded estimates.
202 return current_begin_frame_args_
.deadline
-
203 BeginFrameArgs::DefaultEstimatedParentDrawTime();
206 TRACE_EVENT_INSTANT0("cc", "More damage expected soon",
207 TRACE_EVENT_SCOPE_THREAD
);
208 return current_begin_frame_args_
.deadline
;
211 void DisplayScheduler::ScheduleBeginFrameDeadline() {
212 TRACE_EVENT0("cc", "DisplayScheduler::ScheduleBeginFrameDeadline");
214 // We need to wait for the next BeginFrame before scheduling a deadline.
215 if (!inside_begin_frame_deadline_interval_
) {
216 TRACE_EVENT_INSTANT0("cc", "Waiting for next BeginFrame",
217 TRACE_EVENT_SCOPE_THREAD
);
218 DCHECK(begin_frame_deadline_task_
.IsCancelled());
222 // Determine the deadline we want to use.
223 base::TimeTicks desired_deadline
= DesiredBeginFrameDeadlineTime();
225 // Avoid re-scheduling the deadline if it's already correctly scheduled.
226 if (!begin_frame_deadline_task_
.IsCancelled() &&
227 desired_deadline
== begin_frame_deadline_task_time_
) {
228 TRACE_EVENT_INSTANT0("cc", "Using existing deadline",
229 TRACE_EVENT_SCOPE_THREAD
);
233 // Schedule the deadline.
234 begin_frame_deadline_task_time_
= desired_deadline
;
235 begin_frame_deadline_task_
.Cancel();
236 begin_frame_deadline_task_
.Reset(begin_frame_deadline_closure_
);
238 base::TimeDelta delta
=
239 std::max(base::TimeDelta(), desired_deadline
- base::TimeTicks::Now());
240 task_runner_
->PostDelayedTask(FROM_HERE
,
241 begin_frame_deadline_task_
.callback(), delta
);
242 TRACE_EVENT2("cc", "Using new deadline", "delta", delta
.ToInternalValue(),
243 "desired_deadline", desired_deadline
);
246 void DisplayScheduler::AttemptDrawAndSwap() {
247 inside_begin_frame_deadline_interval_
= false;
248 begin_frame_deadline_task_
.Cancel();
249 begin_frame_deadline_task_time_
= base::TimeTicks();
251 if (needs_draw_
&& !output_surface_lost_
) {
252 if (pending_swaps_
< max_pending_swaps_
&& !root_surface_resources_locked_
)
255 // We are going idle, so reset expectations.
256 child_surface_ids_to_expect_damage_from_
.clear();
257 child_surface_ids_damaged_prev_
.clear();
258 child_surface_ids_damaged_
.clear();
259 all_active_child_surfaces_ready_to_draw_
= true;
260 expect_damage_from_root_surface_
= false;
262 begin_frame_source_
->SetNeedsBeginFrames(false);
266 void DisplayScheduler::OnBeginFrameDeadline() {
267 TRACE_EVENT0("cc", "DisplayScheduler::OnBeginFrameDeadline");
269 AttemptDrawAndSwap();
270 begin_frame_source_
->DidFinishFrame(0);
273 void DisplayScheduler::DidSwapBuffers() {
275 TRACE_EVENT1("cc", "DisplayScheduler::DidSwapBuffers", "pending_frames",
279 void DisplayScheduler::DidSwapBuffersComplete() {
281 TRACE_EVENT1("cc", "DisplayScheduler::DidSwapBuffersComplete",
282 "pending_frames", pending_swaps_
);
283 ScheduleBeginFrameDeadline();