cc: Also trace the scheduler client state

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/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 104 matching lines @@
 }
 
 void Scheduler::DidCreateAndInitializeOutputSurface() {
   TRACE_EVENT0("cc", "Scheduler::DidCreateAndInitializeOutputSurface");
   DCHECK(!last_set_needs_begin_impl_frame_);
   DCHECK(begin_impl_frame_deadline_closure_.IsCancelled());
   state_machine_.DidCreateAndInitializeOutputSurface();
   ProcessScheduledActions();
 }
 
-base::TimeTicks Scheduler::AnticipatedDrawTime() {
-  TRACE_EVENT0("cc", "Scheduler::AnticipatedDrawTime");
-
+base::TimeTicks Scheduler::AnticipatedDrawTime() const {
   if (!last_set_needs_begin_impl_frame_ ||
       last_begin_impl_frame_args_.interval <= base::TimeDelta())
     return base::TimeTicks();
 
   base::TimeTicks now = gfx::FrameTime::Now();
   base::TimeTicks timebase = std::max(last_begin_impl_frame_args_.frame_time,
                                       last_begin_impl_frame_args_.deadline);
   int64 intervals =
       1 + ((now - timebase) / last_begin_impl_frame_args_.interval);
   return timebase + (last_begin_impl_frame_args_.interval * intervals);
@@ skipping 176 matching lines @@
 
   base::AutoReset<bool> mark_inside(&inside_process_scheduled_actions_, true);
 
   SchedulerStateMachine::Action action;
   do {
     state_machine_.CheckInvariants();
     action = state_machine_.NextAction();
     TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                  "SchedulerStateMachine",
                  "state",
-                 TracedValue::FromValue(state_machine_.AsValue().release()));
+                 TracedValue::FromValue(StateAsValue().release()));
     state_machine_.UpdateState(action);
     base::AutoReset<SchedulerStateMachine::Action>
         mark_inside_action(&inside_action_, action);
     switch (action) {
       case SchedulerStateMachine::ACTION_NONE:
         break;
       case SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME:
         client_->ScheduledActionSendBeginMainFrame();
         break;
       case SchedulerStateMachine::ACTION_COMMIT:
@@ skipping 34 matching lines @@
   client_->DidAnticipatedDrawTimeChange(AnticipatedDrawTime());
 
   if (state_machine_.ShouldTriggerBeginImplFrameDeadlineEarly())
     PostBeginImplFrameDeadline(base::TimeTicks());
 }
 
 bool Scheduler::WillDrawIfNeeded() const {
   return !state_machine_.PendingDrawsShouldBeAborted();
 }
 
+scoped_ptr<base::Value> Scheduler::StateAsValue() const {
+  scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue);
+  state->Set("state_machine", state_machine_.AsValue().release());
+  state->SetDouble(
+      "time_until_anticipated_draw_time_ms",
+      (AnticipatedDrawTime() - base::TimeTicks::Now()).InMillisecondsF());
+
+  scoped_ptr<base::DictionaryValue> client_state(new base::DictionaryValue);
+  client_state->SetDouble("draw_duration_estimate_ms",
+                          client_->DrawDurationEstimate().InMillisecondsF());
+  client_state->SetDouble(
+      "begin_main_frame_to_commit_duration_estimate_ms",
+      client_->BeginMainFrameToCommitDurationEstimate().InMillisecondsF());
+  client_state->SetDouble(
+      "commit_to_activate_duration_estimate_ms",
+      client_->CommitToActivateDurationEstimate().InMillisecondsF());
+  state->Set("client_state", client_state.release());
+  return state.PassAs<base::Value>();
+}
+
 bool Scheduler::CanCommitAndActivateBeforeDeadline() const {
   // Check if the main thread computation and commit can be finished before the
   // impl thread's deadline.
   base::TimeTicks estimated_draw_time =
       last_begin_impl_frame_args_.frame_time +
       client_->BeginMainFrameToCommitDurationEstimate() +
       client_->CommitToActivateDurationEstimate();
 
+  TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
+               "CanCommitAndActivateBeforeDeadline",
+               "time_left_after_drawing_ms",
+               (last_begin_impl_frame_args_.deadline - estimated_draw_time)
+                   .InMillisecondsF(),
+               "state",
+               TracedValue::FromValue(StateAsValue().release()));
+
   return estimated_draw_time < last_begin_impl_frame_args_.deadline;
 }
 
 }  // namespace cc