Add DisplayScheduler for Surfaces

cc/surfaces/display_scheduler.cc

+// 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_ to be stale (incorrectly
false) if the browser is damaged after the renderer is damaged?

[brianderson, 2015/05/02 03:28:37]

I will add a unit test to verify, but it should be ok. I tried to avoid that
situation by not keeping track of the browser_surface_id_ in the
surface_ids_damaged_.

The all_active_surfaces_ready_to_draw_ name is deceiving. I will give it a
better name.

+  } 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 if we're waiting on damage from
the browser?

Also, is there any theoretical justification for using
DefaultEstimatedParentDrawTime here? We already subtracted that (to account for
the time to draw this surface) in OnBeginFrameMixInDelegate.

[brianderson, 2015/05/02 03:28:37]

As coded, it will. I need to rename all_active_surfaces_ready_to_draw_.
I need to verify that this solution is actually helpful in practice. It's
intended to solve the problem where the Browser goes inactive and we wait for it
too long and miss the vsync. We saw that this was a problem on Sunny's Windows
machine yesterday.
 
Theoretically, the justification is that Surfaces and the UI run on the same
thread and run serially. If we give Surfaces 1/3 of the vsync and the UI 1/3 of
the vsync, the UI can have up till 1/3 of the vsync in to *start* producing
(which is what this deadline represents). If the UI starts to draw before this
point, it will lock the resources and we'll wait for it to unlock before we
draw.

I will update the comments with better justification.

It would be nice to replace these constants with better estimates and replace
these heuristics with better coordination, but I'm hoping we can leave that to
followup patches.

+  }
+
+  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