Index: cc/surfaces/display_scheduler.cc |
diff --git a/cc/surfaces/display_scheduler.cc b/cc/surfaces/display_scheduler.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..bb7182cb9037772ddb4b680214588c0778492cc6 |
--- /dev/null |
+++ b/cc/surfaces/display_scheduler.cc |
@@ -0,0 +1,262 @@ |
+// 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. |
+ |
+#include "cc/surfaces/display_scheduler.h" |
+ |
+#include <vector> |
+ |
+#include "base/stl_util.h" |
+#include "base/trace_event/trace_event.h" |
+#include "cc/output/output_surface.h" |
+#include "ui/gfx/frame_time.h" |
+ |
+namespace cc { |
+ |
+DisplayScheduler::DisplayScheduler( |
+ DisplaySchedulerClient* client, |
+ BeginFrameSource* begin_frame_source, |
+ scoped_refptr<base::SingleThreadTaskRunner> task_runner, |
+ int max_pending_swaps) |
+ : client_(client), |
+ begin_frame_source_(begin_frame_source), |
+ task_runner_(task_runner), |
+ output_surface_lost_(false), |
+ resources_locked_by_browser_(true), |
+ inside_begin_frame_deadline_interval_(false), |
+ needs_draw_(false), |
+ entire_display_damaged_(false), |
+ all_active_surfaces_ready_to_draw_(false), |
+ pending_swaps_(0), |
+ max_pending_swaps_(max_pending_swaps), |
+ browser_damaged_(false), |
+ expect_damage_from_browser_(false), |
+ weak_ptr_factory_(this) { |
+ begin_frame_source_->AddObserver(this); |
+ begin_frame_deadline_closure_ = base::Bind( |
+ &DisplayScheduler::OnBeginFrameDeadline, weak_ptr_factory_.GetWeakPtr()); |
+} |
+ |
+DisplayScheduler::~DisplayScheduler() { |
+ begin_frame_source_->RemoveObserver(this); |
+} |
+ |
+// If we try to draw when the Browser has locked it's resources, the |
+// draw will fail. |
+void DisplayScheduler::SetResourcesLockedByBrowser(bool locked) { |
+ resources_locked_by_browser_ = locked; |
+ ScheduleBeginFrameDeadline(); |
+} |
+ |
+// Notification that there was a resize or the root surface changed and |
+// that we should just draw immediately. |
+void DisplayScheduler::EntireDisplayDamaged(SurfaceId browser_surface_id) { |
+ TRACE_EVENT0("cc", "DisplayScheduler::EntireDisplayDamaged"); |
+ needs_draw_ = true; |
+ entire_display_damaged_ = true; |
+ browser_surface_id_ = browser_surface_id; |
+ |
+ begin_frame_source_->SetNeedsBeginFrames(!output_surface_lost_); |
+ ScheduleBeginFrameDeadline(); |
+} |
+ |
+// Indicates that there was damage to one of the surfaces. |
+// Has some logic to wait for multiple active surfaces before |
+// triggering the deadline. |
+void DisplayScheduler::SurfaceDamaged(SurfaceId surface_id) { |
+ TRACE_EVENT1("cc", "DisplayScheduler::SurfaceDamaged", "surface_id", |
+ surface_id.id); |
+ |
+ needs_draw_ = true; |
+ |
+ if (surface_id == browser_surface_id_) { |
+ browser_damaged_ = true; |
jbauman
2015/05/02 01:20:03
Could this cause all_active_surfaces_ready_to_draw
brianderson
2015/05/02 03:28:37
I will add a unit test to verify, but it should be
|
+ } else { |
+ surface_ids_damaged_.insert(surface_id); |
+ |
+ // TODO(mithro): Use hints from SetNeedsBeginFrames and SwapAborts. |
+ all_active_surfaces_ready_to_draw_ = base::STLIncludes( |
+ surface_ids_damaged_, surface_ids_to_expect_damage_from_); |
+ } |
+ |
+ begin_frame_source_->SetNeedsBeginFrames(!output_surface_lost_); |
+ ScheduleBeginFrameDeadline(); |
+} |
+ |
+void DisplayScheduler::OutputSurfaceLost() { |
+ TRACE_EVENT0("cc", "DisplayScheduler::OutputSurfaceLost"); |
+ output_surface_lost_ = true; |
+ begin_frame_source_->SetNeedsBeginFrames(false); |
+ ScheduleBeginFrameDeadline(); |
+} |
+ |
+void DisplayScheduler::DrawAndSwap() { |
+ TRACE_EVENT0("cc", "DisplayScheduler::DrawAndSwap"); |
+ DCHECK_LT(pending_swaps_, max_pending_swaps_); |
+ DCHECK(!output_surface_lost_); |
+ |
+ bool success = client_->DrawAndSwap(); |
+ if (!success) |
+ return; |
+ |
+ needs_draw_ = false; |
+ entire_display_damaged_ = false; |
+ all_active_surfaces_ready_to_draw_ = false; |
+ |
+ expect_damage_from_browser_ = browser_damaged_; |
+ browser_damaged_ = false; |
+ |
+ surface_ids_to_expect_damage_from_ = |
+ base::STLSetIntersection<std::vector<SurfaceId>>( |
+ surface_ids_damaged_, surface_ids_damaged_prev_); |
+ |
+ surface_ids_damaged_prev_.swap(surface_ids_damaged_); |
+ surface_ids_damaged_.clear(); |
+} |
+ |
+bool DisplayScheduler::OnBeginFrameMixInDelegate(const BeginFrameArgs& args) { |
+ base::TimeTicks now = gfx::FrameTime::Now(); |
+ TRACE_EVENT2("cc", "DisplayScheduler::BeginFrame", "args", args.AsValue(), |
+ "now", now); |
+ |
+ // Only service missed BeginFrames if they haven't already expired. |
+ base::TimeTicks adjusted_deadline = |
+ args.deadline - BeginFrameArgs::DefaultEstimatedParentDrawTime(); |
+ if (args.type == BeginFrameArgs::MISSED && now > adjusted_deadline) |
+ return false; |
+ |
+ // If we get another BeginFrame before the previous deadline, |
+ // synchronously trigger the previous deadline before progressing. |
+ if (inside_begin_frame_deadline_interval_) { |
+ OnBeginFrameDeadline(); |
+ } |
+ |
+ // Schedule the deadline. |
+ current_begin_frame_args_ = args; |
+ current_begin_frame_args_.deadline = adjusted_deadline; |
+ inside_begin_frame_deadline_interval_ = true; |
+ ScheduleBeginFrameDeadline(); |
+ |
+ return true; |
+} |
+ |
+base::TimeTicks DisplayScheduler::DesiredBeginFrameDeadlineTime() { |
+ if (output_surface_lost_) { |
+ TRACE_EVENT_INSTANT0("cc", "Lost output surface", TRACE_EVENT_SCOPE_THREAD); |
+ return base::TimeTicks(); |
+ } |
+ |
+ if (pending_swaps_ >= max_pending_swaps_) { |
+ TRACE_EVENT_INSTANT0("cc", "Swap throttled", TRACE_EVENT_SCOPE_THREAD); |
+ return current_begin_frame_args_.deadline; |
+ } |
+ |
+ if (!needs_draw_) { |
+ TRACE_EVENT_INSTANT0("cc", "No damage yet", TRACE_EVENT_SCOPE_THREAD); |
+ return current_begin_frame_args_.frame_time + |
+ current_begin_frame_args_.interval; |
+ } |
+ |
+ if (resources_locked_by_browser_) { |
+ TRACE_EVENT_INSTANT0("cc", "Resources locked by Browser", |
+ TRACE_EVENT_SCOPE_THREAD); |
+ return current_begin_frame_args_.frame_time + |
+ current_begin_frame_args_.interval; |
+ } |
+ |
+ // TODO(mithro): Be smarter about resize deadlines. |
+ if (entire_display_damaged_) { |
+ TRACE_EVENT_INSTANT0("cc", "Entire display damaged", |
+ TRACE_EVENT_SCOPE_THREAD); |
+ return base::TimeTicks(); |
+ } |
+ |
+ bool browser_ready_to_draw = !expect_damage_from_browser_ || browser_damaged_; |
+ |
+ if (all_active_surfaces_ready_to_draw_ && browser_ready_to_draw) { |
+ TRACE_EVENT_INSTANT0("cc", "All active surfaces ready", |
+ TRACE_EVENT_SCOPE_THREAD); |
+ return base::TimeTicks(); |
+ } |
+ |
+ // Use an earlier deadline if we are only waiting for the browser |
+ // in case our expect_damage_from_browser heuristic is incorrect. |
+ // TODO(mithro): Replace this with SetNeedsBeginFrame and SwapAbort |
+ // logic. |
+ if (all_active_surfaces_ready_to_draw_ && expect_damage_from_browser_) { |
+ TRACE_EVENT_INSTANT0("cc", "Waiting for damage from Browser", |
+ TRACE_EVENT_SCOPE_THREAD); |
+ return current_begin_frame_args_.deadline - |
+ BeginFrameArgs::DefaultEstimatedParentDrawTime(); |
jbauman
2015/05/02 01:20:03
Would all_active_surfaces_ready_to_draw_ be true i
brianderson
2015/05/02 03:28:37
As coded, it will. I need to rename all_active_sur
|
+ } |
+ |
+ TRACE_EVENT_INSTANT0("cc", "More damage expected soon", |
+ TRACE_EVENT_SCOPE_THREAD); |
+ return current_begin_frame_args_.deadline; |
+} |
+ |
+void DisplayScheduler::ScheduleBeginFrameDeadline() { |
+ TRACE_EVENT0("cc", "DisplayScheduler::ScheduleBeginFrameDeadline"); |
+ |
+ // We need to wait for the next BeginFrame before scheduling a deadline. |
+ if (!inside_begin_frame_deadline_interval_) { |
+ TRACE_EVENT_INSTANT0("cc", "Waiting for next BeginFrame", |
+ TRACE_EVENT_SCOPE_THREAD); |
+ DCHECK(begin_frame_deadline_task_.IsCancelled()); |
+ return; |
+ } |
+ |
+ // Determine the deadline we want to use. |
+ base::TimeTicks desired_deadline = DesiredBeginFrameDeadlineTime(); |
+ |
+ // Avoid re-scheduling the deadline if it's already correctly scheduled. |
+ if (!begin_frame_deadline_task_.IsCancelled() && |
+ desired_deadline == begin_frame_deadline_task_time_) { |
+ TRACE_EVENT_INSTANT0("cc", "Using existing deadline", |
+ TRACE_EVENT_SCOPE_THREAD); |
+ return; |
+ } |
+ |
+ // Schedule the deadline. |
+ begin_frame_deadline_task_time_ = desired_deadline; |
+ begin_frame_deadline_task_.Cancel(); |
+ begin_frame_deadline_task_.Reset(begin_frame_deadline_closure_); |
+ |
+ base::TimeDelta delta = |
+ std::max(base::TimeDelta(), desired_deadline - gfx::FrameTime::Now()); |
+ task_runner_->PostDelayedTask(FROM_HERE, |
+ begin_frame_deadline_task_.callback(), delta); |
+ TRACE_EVENT2("cc", "Using new deadline", "delta", delta.ToInternalValue(), |
+ "desired_deadline", desired_deadline); |
+} |
+ |
+void DisplayScheduler::OnBeginFrameDeadline() { |
+ TRACE_EVENT0("cc", "DisplayScheduler::OnBeginFrameDeadline"); |
+ inside_begin_frame_deadline_interval_ = false; |
+ begin_frame_deadline_task_.Cancel(); |
+ begin_frame_deadline_task_time_ = base::TimeTicks(); |
+ |
+ if (needs_draw_ && !output_surface_lost_) { |
+ if (pending_swaps_ < max_pending_swaps_ && !resources_locked_by_browser_) |
+ DrawAndSwap(); |
+ } else { |
+ begin_frame_source_->SetNeedsBeginFrames(false); |
+ } |
+ |
+ begin_frame_source_->DidFinishFrame(0); |
+} |
+ |
+void DisplayScheduler::DidSwapBuffers() { |
+ pending_swaps_++; |
+ TRACE_EVENT1("cc", "DisplayScheduler::DidSwapBuffers", "pending_frames", |
+ pending_swaps_); |
+} |
+ |
+void DisplayScheduler::DidSwapBuffersComplete() { |
+ pending_swaps_--; |
+ TRACE_EVENT1("cc", "DisplayScheduler::DidSwapBuffersComplete", |
+ "pending_frames", pending_swaps_); |
+ ScheduleBeginFrameDeadline(); |
+} |
+ |
+} // namespace cc |