cc: Adding BeginFrameTracker object and removing Now() from LTHI.

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 61 matching lines @@
       vsync_observer_(NULL),
       authoritative_vsync_interval_(base::TimeDelta()),
       last_vsync_timebase_(base::TimeTicks()),
       throttle_frame_production_(false),
       settings_(scheduler_settings),
       client_(client),
       layer_tree_host_id_(layer_tree_host_id),
       task_runner_(task_runner),
       begin_impl_frame_deadline_mode_(
           SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_NONE),
+      begin_impl_frame_tracker_(BEGINFRAMETRACKER_FROM_HERE),
       state_machine_(scheduler_settings),
       inside_process_scheduled_actions_(false),
       inside_action_(SchedulerStateMachine::ACTION_NONE),
       weak_factory_(this) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                "Scheduler::Scheduler",
                "settings",
                settings_.AsValue());
   DCHECK(client_);
   DCHECK(!state_machine_.BeginFrameNeeded());
@@ skipping 176 matching lines @@
   ProcessScheduledActions();
 }
 
 void Scheduler::NotifyBeginMainFrameStarted() {
   TRACE_EVENT0("cc", "Scheduler::NotifyBeginMainFrameStarted");
   state_machine_.NotifyBeginMainFrameStarted();
 }
 
 base::TimeTicks Scheduler::AnticipatedDrawTime() const {
   if (!frame_source_->NeedsBeginFrames() ||
-      begin_impl_frame_args_.interval <= base::TimeDelta())
+      begin_impl_frame_tracker_.DangerousMethodHasFinished())
     return base::TimeTicks();
 
   base::TimeTicks now = Now();
-  base::TimeTicks timebase = std::max(begin_impl_frame_args_.frame_time,
-                                      begin_impl_frame_args_.deadline);
-  int64 intervals = 1 + ((now - timebase) / begin_impl_frame_args_.interval);
-  return timebase + (begin_impl_frame_args_.interval * intervals);
+  BeginFrameArgs args = begin_impl_frame_tracker_.Current();
+  base::TimeTicks timebase = std::max(args.frame_time, args.deadline);
+  int64 intervals =
+      1 + ((now - timebase) / begin_impl_frame_tracker_.Interval());
+  return timebase + (begin_impl_frame_tracker_.Interval() * intervals);
 }
 
 base::TimeTicks Scheduler::LastBeginImplFrameTime() {
-  return begin_impl_frame_args_.frame_time;
+  return begin_impl_frame_tracker_.Current().frame_time;
 }
 
 void Scheduler::SetupNextBeginFrameIfNeeded() {
   // Never call SetNeedsBeginFrames if the frame source already has the right
   // value.
   if (frame_source_->NeedsBeginFrames() != state_machine_.BeginFrameNeeded()) {
     if (state_machine_.BeginFrameNeeded()) {
       // Call SetNeedsBeginFrames(true) as soon as possible.
       frame_source_->SetNeedsBeginFrames(true);
     } else if (state_machine_.begin_impl_frame_state() ==
@@ skipping 13 matching lines @@
   // At this point we'd prefer to advance through the commit flow by
   // drawing a frame, however it's possible that the frame rate controller
   // will not give us a BeginFrame until the commit completes.  See
   // crbug.com/317430 for an example of a swap ack being held on commit. Thus
   // we set a repeating timer to poll on ProcessScheduledActions until we
   // successfully reach BeginFrame. Synchronous compositor does not use
   // frame rate controller or have the circular wait in the bug.
   if (IsBeginMainFrameSentOrStarted() &&
       !settings_.using_synchronous_renderer_compositor) {
     if (advance_commit_state_task_.IsCancelled() &&
-        begin_impl_frame_args_.IsValid()) {
+        begin_impl_frame_tracker_.DangerousMethodCurrentOrLast().IsValid()) {
       // Since we'd rather get a BeginImplFrame by the normal mechanism, we
       // set the interval to twice the interval from the previous frame.
       advance_commit_state_task_.Reset(advance_commit_state_closure_);
       task_runner_->PostDelayedTask(FROM_HERE,
                                     advance_commit_state_task_.callback(),
-                                    begin_impl_frame_args_.interval * 2);
+                                    begin_impl_frame_tracker_.Interval() * 2);
     }
   } else {
     advance_commit_state_task_.Cancel();
   }
 }
 
 // BeginFrame is the mechanism that tells us that now is a good time to start
 // making a frame. Usually this means that user input for the frame is complete.
 // If the scheduler is busy, we queue the BeginFrame to be handled later as
 // a BeginRetroFrame.
 bool Scheduler::OnBeginFrameMixInDelegate(const BeginFrameArgs& args) {
   TRACE_EVENT1("cc,benchmark", "Scheduler::BeginFrame", "args", args.AsValue());
 
+  // 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());
+
   // Deliver BeginFrames to children.
   if (state_machine_.children_need_begin_frames()) {
     BeginFrameArgs adjusted_args_for_children(args);
     // Adjust a deadline for child schedulers.
     // TODO(simonhong): Once we have commitless update, we can get rid of
     // BeginMainFrameToCommitDurationEstimate() +
     // CommitToActivateDurationEstimate().
     adjusted_args_for_children.deadline -=
         (client_->BeginMainFrameToCommitDurationEstimate() +
          client_->CommitToActivateDurationEstimate() +
@@ skipping 143 matching lines @@
   bool main_thread_is_in_high_latency_mode =
       state_machine_.MainThreadIsInHighLatencyMode();
   TRACE_EVENT2("cc,benchmark", "Scheduler::BeginImplFrame", "args",
                args.AsValue(), "main_thread_is_high_latency",
                main_thread_is_in_high_latency_mode);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                  "MainThreadLatency", main_thread_is_in_high_latency_mode);
 
   advance_commit_state_task_.Cancel();
 
-  begin_impl_frame_args_ = args;
-  begin_impl_frame_args_.deadline -= client_->DrawDurationEstimate();
+  BeginFrameArgs adjusted_args = args;
+  adjusted_args.deadline -= client_->DrawDurationEstimate();
 
   if (!state_machine_.impl_latency_takes_priority() &&
       main_thread_is_in_high_latency_mode &&
       CanCommitAndActivateBeforeDeadline()) {
     state_machine_.SetSkipNextBeginMainFrameToReduceLatency();
   }
 
-  BeginImplFrame();
+  BeginImplFrame(adjusted_args);
 
   // The deadline will be scheduled in ProcessScheduledActions.
   state_machine_.OnBeginImplFrameDeadlinePending();
   ProcessScheduledActions();
 }
 
 void Scheduler::BeginImplFrameSynchronous(const BeginFrameArgs& args) {
   TRACE_EVENT1("cc,benchmark", "Scheduler::BeginImplFrame", "args",
                args.AsValue());
-  begin_impl_frame_args_ = args;
-  BeginImplFrame();
+  BeginImplFrame(args);
   FinishImplFrame();
 }
 
 void Scheduler::FinishImplFrame() {
   state_machine_.OnBeginImplFrameIdle();
   ProcessScheduledActions();
 
   client_->DidBeginImplFrameDeadline();
   frame_source_->DidFinishFrame(begin_retro_frame_args_.size());
+  begin_impl_frame_tracker_.Finish();
 }
 
 // BeginImplFrame starts a compositor frame that will wait up until a deadline
 // for a BeginMainFrame+activation to complete before it times out and draws
 // any asynchronous animation and scroll/pinch updates.
-void Scheduler::BeginImplFrame() {
+void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
   DCHECK_EQ(state_machine_.begin_impl_frame_state(),
             SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
   DCHECK(!BeginImplFrameDeadlinePending());
   DCHECK(state_machine_.HasInitializedOutputSurface());
   DCHECK(advance_commit_state_task_.IsCancelled());
 
+  begin_impl_frame_tracker_.Start(args);
   state_machine_.OnBeginImplFrame();
   devtools_instrumentation::DidBeginFrame(layer_tree_host_id_);
-  client_->WillBeginImplFrame(begin_impl_frame_args_);
+  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_mode_ =
       state_machine_.CurrentBeginImplFrameDeadlineMode();
 
   base::TimeTicks deadline;
   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.
       deadline = base::TimeTicks();
       break;
     case SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_REGULAR:
       // We are animating on the impl thread but we can wait for some time.
-      deadline = begin_impl_frame_args_.deadline;
+      deadline = begin_impl_frame_tracker_.Current().deadline;
       break;
     case SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_LATE:
       // We are blocked for one reason or another and we should wait.
       // TODO(brianderson): Handle long deadlines (that are past the next
       // frame's frame time) properly instead of using this hack.
-      deadline =
-          begin_impl_frame_args_.frame_time + begin_impl_frame_args_.interval;
+      deadline = begin_impl_frame_tracker_.Current().frame_time +
+                 begin_impl_frame_tracker_.Current().interval;
       break;
     case SchedulerStateMachine::
         BEGIN_IMPL_FRAME_DEADLINE_MODE_BLOCKED_ON_READY_TO_DRAW:
       // We are blocked because we are waiting for ReadyToDraw signal. We would
       // post deadline after we received ReadyToDraw singal.
       TRACE_EVENT1("cc", "Scheduler::ScheduleBeginImplFrameDeadline",
                    "deadline_mode", "blocked_on_ready_to_draw");
       return;
   }
 
@@ skipping 175 matching lines @@
   state->SetBoolean("last_set_needs_begin_frame_",
                     frame_source_->NeedsBeginFrames());
   state->SetInteger("begin_retro_frame_args_", begin_retro_frame_args_.size());
   state->SetBoolean("begin_retro_frame_task_",
                     !begin_retro_frame_task_.IsCancelled());
   state->SetBoolean("begin_impl_frame_deadline_task_",
                     !begin_impl_frame_deadline_task_.IsCancelled());
   state->SetBoolean("advance_commit_state_task_",
                     !advance_commit_state_task_.IsCancelled());
   state->BeginDictionary("begin_impl_frame_args");
-  begin_impl_frame_args_.AsValueInto(state);
+  begin_impl_frame_tracker_.AsValueInto(Now(), state);
   state->EndDictionary();
-
-  base::TimeTicks now = Now();
-  base::TimeTicks frame_time = begin_impl_frame_args_.frame_time;
-  base::TimeTicks deadline = begin_impl_frame_args_.deadline;
-  base::TimeDelta interval = begin_impl_frame_args_.interval;
-  state->BeginDictionary("major_timestamps_in_ms");
-  state->SetDouble("0_interval", interval.InMillisecondsF());
-  state->SetDouble("1_now_to_deadline", (deadline - now).InMillisecondsF());
-  state->SetDouble("2_frame_time_to_now", (now - frame_time).InMillisecondsF());
-  state->SetDouble("3_frame_time_to_deadline",
-                   (deadline - frame_time).InMillisecondsF());
-  state->SetDouble("4_now", (now - base::TimeTicks()).InMillisecondsF());
-  state->SetDouble("5_frame_time",
-                   (frame_time - base::TimeTicks()).InMillisecondsF());
-  state->SetDouble("6_deadline",
-                   (deadline - base::TimeTicks()).InMillisecondsF());
-  state->EndDictionary();
-
   state->EndDictionary();
 
   state->BeginDictionary("client_state");
   state->SetDouble("draw_duration_estimate_ms",
                    client_->DrawDurationEstimate().InMillisecondsF());
   state->SetDouble(
       "begin_main_frame_to_commit_duration_estimate_ms",
       client_->BeginMainFrameToCommitDurationEstimate().InMillisecondsF());
   state->SetDouble(
       "commit_to_activate_duration_estimate_ms",
       client_->CommitToActivateDurationEstimate().InMillisecondsF());
   state->EndDictionary();
 }
 
 bool Scheduler::CanCommitAndActivateBeforeDeadline() const {
+  BeginFrameArgs args =
+      begin_impl_frame_tracker_.DangerousMethodCurrentOrLast();

[brianderson, 2015/05/01 02:05:21]

Is there any way to make this not a dangerous call? I see that it's because of
the order BeginImplFramewithDeadline calls things in to be compatibvle with
BeginImplFrameSynchronous. Would callling begin_impl_frame_tracker_.Start(args)
outside BeginImplFrame help?

[mithro-old, 2015/05/01 03:27:56]

Yes, I have a number of ideas about how to do that, but don't want to make this
CL any bigger.

+
   // Check if the main thread computation and commit can be finished before the
   // impl thread's deadline.
   base::TimeTicks estimated_draw_time =
-      begin_impl_frame_args_.frame_time +
-      client_->BeginMainFrameToCommitDurationEstimate() +
+      args.frame_time + client_->BeginMainFrameToCommitDurationEstimate() +
       client_->CommitToActivateDurationEstimate();
 
-  TRACE_EVENT2(
-      TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
-      "CanCommitAndActivateBeforeDeadline",
-      "time_left_after_drawing_ms",
-      (begin_impl_frame_args_.deadline - estimated_draw_time).InMillisecondsF(),
-      "state",
-      AsValue());
+  TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
+               "CanCommitAndActivateBeforeDeadline",
+               "time_left_after_drawing_ms",
+               (args.deadline - estimated_draw_time).InMillisecondsF(), "state",
+               AsValue());
 
-  return estimated_draw_time < begin_impl_frame_args_.deadline;
+  return estimated_draw_time < args.deadline;
 }
 
 bool Scheduler::IsBeginMainFrameSentOrStarted() const {
   return (state_machine_.commit_state() ==
               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT ||
           state_machine_.commit_state() ==
               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED);
 }
 
 }  // namespace cc