Revert of Revert "cc: Make scheduler run incoming frame after previous deadline."

cc/scheduler/scheduler.cc

 // 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.
 
 #include "cc/scheduler/scheduler.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
@@ skipping 26 matching lines @@
       client_(client),
       layer_tree_host_id_(layer_tree_host_id),
       task_runner_(task_runner),
       compositor_timing_history_(std::move(compositor_timing_history)),
       begin_impl_frame_tracker_(BEGINFRAMETRACKER_FROM_HERE),
       state_machine_(settings),
       weak_factory_(this) {
   TRACE_EVENT1("cc", "Scheduler::Scheduler", "settings", settings_.AsValue());
   DCHECK(client_);
   DCHECK(!state_machine_.BeginFrameNeeded());
-
-  begin_impl_frame_deadline_closure_ = base::Bind(
-      &Scheduler::OnBeginImplFrameDeadline, weak_factory_.GetWeakPtr());
-
   ProcessScheduledActions();
 }
 
 Scheduler::~Scheduler() {
   SetBeginFrameSource(nullptr);
 }
 
 void Scheduler::Stop() {
   stopped_ = true;
 }
@@ skipping 157 matching lines @@
 }
 
 void Scheduler::SetupNextBeginFrameIfNeeded() {
   if (state_machine_.begin_impl_frame_state() !=
       SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE) {
     return;
   }
 
   bool needs_begin_frames = state_machine_.BeginFrameNeeded();
   if (needs_begin_frames && !observing_begin_frame_source_) {
-    observing_begin_frame_source_ = true;
-    if (begin_frame_source_)
-      begin_frame_source_->AddObserver(this);
-    devtools_instrumentation::NeedsBeginFrameChanged(layer_tree_host_id_, true);
+    StartObservingBeginFrameSource();
   } else if (!needs_begin_frames && observing_begin_frame_source_) {
-    observing_begin_frame_source_ = false;
-    if (begin_frame_source_)
-      begin_frame_source_->RemoveObserver(this);
-    missed_begin_frame_task_.Cancel();
-    BeginImplFrameNotExpectedSoon();
-    devtools_instrumentation::NeedsBeginFrameChanged(layer_tree_host_id_,
-                                                     false);
+    StopObservingBeginFrameSource();
+  }
+
+  if (missed_begin_frame_args_.IsValid()) {
+    DCHECK(observing_begin_frame_source_);
+    DCHECK(missed_begin_frame_task_.IsCancelled());
+    missed_begin_frame_task_.Reset(base::Bind(&Scheduler::BeginImplFrameMissed,
+                                              weak_factory_.GetWeakPtr(),
+                                              missed_begin_frame_args_));
+    missed_begin_frame_args_ = BeginFrameArgs();
+    task_runner_->PostTask(FROM_HERE, missed_begin_frame_task_.callback());
   }
 }
 
+void Scheduler::StartObservingBeginFrameSource() {
+  observing_begin_frame_source_ = true;
+
+  if (begin_frame_source_)
+    begin_frame_source_->AddObserver(this);
+
+  devtools_instrumentation::NeedsBeginFrameChanged(layer_tree_host_id_, true);
+}
+
+void Scheduler::StopObservingBeginFrameSource() {
+  observing_begin_frame_source_ = false;
+
+  if (begin_frame_source_)
+    begin_frame_source_->RemoveObserver(this);
+
+  missed_begin_frame_task_.Cancel();
+
+  if (missed_begin_frame_args_.IsValid()) {
+    // We need to confirm the ignored BeginFrame, since we don't have updates.
+    // To persist the confirmation for future BeginFrameAcks, we let the state
+    // machine know about the BeginFrame.
+    state_machine_.OnBeginFrameDroppedNotObserving(
+        missed_begin_frame_args_.source_id,
+        missed_begin_frame_args_.sequence_number);
+    SendBeginFrameAck(missed_begin_frame_args_, kBeginFrameSkipped);
+    missed_begin_frame_args_ = BeginFrameArgs();
+  }
+
+  BeginImplFrameNotExpectedSoon();
+
+  devtools_instrumentation::NeedsBeginFrameChanged(layer_tree_host_id_, false);
+}
+
 void Scheduler::OnBeginFrameSourcePausedChanged(bool paused) {
   if (state_machine_.begin_frame_source_paused() == paused)
     return;
   TRACE_EVENT_INSTANT1("cc", "Scheduler::SetBeginFrameSourcePaused",
                        TRACE_EVENT_SCOPE_THREAD, "paused", paused);
   state_machine_.SetBeginFrameSourcePaused(paused);
   ProcessScheduledActions();
 }
 
 // BeginFrame is the mechanism that tells us that now is a good time to start
@@ skipping 16 matching lines @@
   // Trace this begin frame time through the Chrome stack
   TRACE_EVENT_FLOW_BEGIN0(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"), "BeginFrameArgs",
       args.frame_time.ToInternalValue());
 
   if (settings_.using_synchronous_renderer_compositor) {
     BeginImplFrameSynchronous(args);
     return true;
   }
 
-  if (inside_process_scheduled_actions_) {
-    // The BFS can send a missed begin frame inside AddObserver. We can't handle
-    // a begin frame inside ProcessScheduledActions so post a task.
-    DCHECK_EQ(args.type, BeginFrameArgs::MISSED);
-    DCHECK(missed_begin_frame_task_.IsCancelled());
-    missed_begin_frame_task_.Reset(base::Bind(
-        &Scheduler::BeginImplFrameWithDeadline, base::Unretained(this), args));
-    task_runner_->PostTask(FROM_HERE, missed_begin_frame_task_.callback());
+  // Cancel any pending missed begin frame task because we're either handling
+  // this begin frame immediately or saving it as a missed frame for which we
+  // will post a new task.
+  missed_begin_frame_task_.Cancel();
+
+  // Save args if we're inside ProcessScheduledActions or the middle of a frame.
+  // At the end of ProcessScheduledActions and at the end of the current frame,
+  // we will post a task to handle the missed begin frame.
+  bool inside_begin_frame =
+      state_machine_.begin_impl_frame_state() ==
+      SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME;
+  if (inside_process_scheduled_actions_ || inside_begin_frame) {
+    missed_begin_frame_args_ = args;
+    missed_begin_frame_args_.type = BeginFrameArgs::MISSED;
     return true;
   }
 
   BeginImplFrameWithDeadline(args);
   return true;
 }
 
 void Scheduler::SetVideoNeedsBeginFrames(bool video_needs_begin_frames) {
   state_machine_.SetVideoNeedsBeginFrames(video_needs_begin_frames);
   ProcessScheduledActions();
 }
 
 void Scheduler::OnDrawForCompositorFrameSink(bool resourceless_software_draw) {
   DCHECK(settings_.using_synchronous_renderer_compositor);
   DCHECK_EQ(state_machine_.begin_impl_frame_state(),
             SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
   DCHECK(begin_impl_frame_deadline_task_.IsCancelled());
 
   state_machine_.SetResourcelessSoftwareDraw(resourceless_software_draw);
   state_machine_.OnBeginImplFrameDeadline();
   ProcessScheduledActions();
 
   state_machine_.OnBeginImplFrameIdle();
   ProcessScheduledActions();
   state_machine_.SetResourcelessSoftwareDraw(false);
 }
 
+void Scheduler::BeginImplFrameMissed(const BeginFrameArgs& args) {
+  // The storage for the args is owned by the task so copy them before canceling
+  // the task.
+  BeginFrameArgs copy_args = args;
+  missed_begin_frame_task_.Cancel();
+  BeginImplFrameWithDeadline(copy_args);
+}
+
 void Scheduler::BeginImplFrameWithDeadline(const BeginFrameArgs& args) {
-  // The storage for |args| is owned by the missed begin frame task. Therefore
-  // save |args| before cancelling the task either here or in the deadline.
-  BeginFrameArgs adjusted_args = args;
-  // Cancel the missed begin frame task in case the BFS sends a begin frame
-  // before the missed frame task runs.
-  missed_begin_frame_task_.Cancel();
+  DCHECK(!inside_process_scheduled_actions_);
+  DCHECK_EQ(state_machine_.begin_impl_frame_state(),
+            SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
 
   base::TimeTicks now = Now();
 
   // Discard missed begin frames if they are too late.
-  if (adjusted_args.type == BeginFrameArgs::MISSED &&
-      now > adjusted_args.deadline) {
+  if (args.type == BeginFrameArgs::MISSED && now > args.deadline) {
     skipped_last_frame_missed_exceeded_deadline_ = true;
-    SendBeginFrameAck(adjusted_args, kBeginFrameSkipped);
+    SendBeginFrameAck(args, kBeginFrameSkipped);
     return;
   }
 
   skipped_last_frame_missed_exceeded_deadline_ = false;
 
-  // Run the previous deadline if any.
-  if (state_machine_.begin_impl_frame_state() ==
-      SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME) {
-    OnBeginImplFrameDeadline();
-    // We may not need begin frames any longer.
-    if (!observing_begin_frame_source_) {
-      // We need to confirm the ignored BeginFrame, since we don't have updates.
-      // To persist the confirmation for future BeginFrameAcks, we let the state
-      // machine know about the BeginFrame.
-      state_machine_.OnBeginFrameDroppedNotObserving(args.source_id,
-                                                     args.sequence_number);
-      SendBeginFrameAck(adjusted_args, kBeginFrameSkipped);
-      return;
-    }
-  }
-  DCHECK_EQ(state_machine_.begin_impl_frame_state(),
-            SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
-
   bool main_thread_is_in_high_latency_mode =
       state_machine_.main_thread_missed_last_deadline();
   TRACE_EVENT2("cc,benchmark", "Scheduler::BeginImplFrame", "args",
-               adjusted_args.AsValue(), "main_thread_missed_last_deadline",
+               args.AsValue(), "main_thread_missed_last_deadline",
                main_thread_is_in_high_latency_mode);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                  "MainThreadLatency", main_thread_is_in_high_latency_mode);
 
-  DCHECK_EQ(state_machine_.begin_impl_frame_state(),
-            SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
-
+  BeginFrameArgs adjusted_args = args;
   adjusted_args.deadline -= compositor_timing_history_->DrawDurationEstimate();
   adjusted_args.deadline -= kDeadlineFudgeFactor;
 
   base::TimeDelta bmf_start_to_activate =
       compositor_timing_history_
           ->BeginMainFrameStartToCommitDurationEstimate() +
       compositor_timing_history_->CommitToReadyToActivateDurationEstimate() +
       compositor_timing_history_->ActivateDurationEstimate();
 
   base::TimeDelta bmf_to_activate_estimate_critical =
@@ skipping 48 matching lines @@
   begin_main_frame_args_.on_critical_path = !ImplLatencyTakesPriority();
 
   BeginImplFrame(args, Now());
   compositor_timing_history_->WillFinishImplFrame(
       state_machine_.needs_redraw());
   FinishImplFrame();
 }
 
 void Scheduler::FinishImplFrame() {
   state_machine_.OnBeginImplFrameIdle();
+
+  // Call this before ProcessScheduledActions because we might send an ack for
+  // missed begin frame there.
+  SendBeginFrameAck(begin_impl_frame_tracker_.Current(), kBeginFrameFinished);
+
   ProcessScheduledActions();
 
   client_->DidFinishImplFrame();
-  SendBeginFrameAck(begin_main_frame_args_, kBeginFrameFinished);
   begin_impl_frame_tracker_.Finish();
 }
 
 void Scheduler::SendBeginFrameAck(const BeginFrameArgs& args,
                                   BeginFrameResult result) {
   if (!begin_frame_source_)
     return;
 
   uint64_t latest_confirmed_sequence_number =
       BeginFrameArgs::kInvalidFrameNumber;
@@ skipping 30 matching lines @@
       state_machine_.NewActiveTreeLikely(), args.frame_time, args.type, now);
   client_->WillBeginImplFrame(begin_impl_frame_tracker_.Current());
 
   ProcessScheduledActions();
 }
 
 void Scheduler::ScheduleBeginImplFrameDeadline() {
   // The synchronous compositor does not post a deadline task.
   DCHECK(!settings_.using_synchronous_renderer_compositor);
 
-  begin_impl_frame_deadline_task_.Cancel();
-  begin_impl_frame_deadline_task_.Reset(begin_impl_frame_deadline_closure_);
+  begin_impl_frame_deadline_task_.Reset(base::Bind(
+      &Scheduler::OnBeginImplFrameDeadline, weak_factory_.GetWeakPtr()));
 
   begin_impl_frame_deadline_mode_ =
       state_machine_.CurrentBeginImplFrameDeadlineMode();
   switch (begin_impl_frame_deadline_mode_) {
     case SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_NONE:
       // No deadline.
       return;
     case SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_IMMEDIATE:
       // We are ready to draw a new active tree immediately.
       // We don't use Now() here because it's somewhat expensive to call.
@@ skipping 182 matching lines @@
 }
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 Scheduler::AsValue() const {
   auto state = base::MakeUnique<base::trace_event::TracedValue>();
   AsValueInto(state.get());
   return std::move(state);
 }
 
 void Scheduler::AsValueInto(base::trace_event::TracedValue* state) const {
-  base::TimeTicks now = Now();
-
   state->BeginDictionary("state_machine");
   state_machine_.AsValueInto(state);
   state->EndDictionary();
 
   state->SetBoolean("observing_begin_frame_source",
                     observing_begin_frame_source_);
   state->SetBoolean("begin_impl_frame_deadline_task",
                     !begin_impl_frame_deadline_task_.IsCancelled());
   state->SetBoolean("missed_begin_frame_task",
                     !missed_begin_frame_task_.IsCancelled());
@@ skipping 12 matching lines @@
   state->SetDouble(
       "deadline_scheduled_at_ms",
       (deadline_scheduled_at_ - base::TimeTicks()).InMillisecondsF());
 
   state->SetDouble("now_ms", (Now() - base::TimeTicks()).InMillisecondsF());
   state->SetDouble("now_to_deadline_ms", (deadline_ - Now()).InMillisecondsF());
   state->SetDouble("now_to_deadline_scheduled_at_ms",
                    (deadline_scheduled_at_ - Now()).InMillisecondsF());
 
   state->BeginDictionary("begin_impl_frame_tracker");
-  begin_impl_frame_tracker_.AsValueInto(now, state);
+  begin_impl_frame_tracker_.AsValueInto(state);
   state->EndDictionary();
 
-  state->BeginDictionary("begin_impl_frame_args");
-  begin_impl_frame_tracker_.AsValueInto(now, state);
+  state->BeginDictionary("missed_begin_frame_args");
+  missed_begin_frame_args_.AsValueInto(state);
   state->EndDictionary();
 
   state->BeginDictionary("begin_frame_observer_state");
   BeginFrameObserverBase::AsValueInto(state);
   state->EndDictionary();
 
   if (begin_frame_source_) {
     state->BeginDictionary("begin_frame_source_state");
     begin_frame_source_->AsValueInto(state);
     state->EndDictionary();
@@ skipping 89 matching lines @@
 }
 
 BeginFrameAck Scheduler::CurrentBeginFrameAckForActiveTree() const {
   return BeginFrameAck(
       begin_main_frame_args_.source_id, begin_main_frame_args_.sequence_number,
       state_machine_.last_begin_frame_sequence_number_active_tree_was_fresh(),
       true);
 }
 
 }  // namespace cc