Plumb activation time to main

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 71 matching lines @@
   state_machine_.SetVisible(visible);
   UpdateCompositorTimingHistoryRecordingEnabled();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetCanDraw(bool can_draw) {
   state_machine_.SetCanDraw(can_draw);
   ProcessScheduledActions();
 }
 
-void Scheduler::NotifyReadyToActivate() {
+void Scheduler::NotifyReadyToActivate(int source_frame_number) {
   compositor_timing_history_->ReadyToActivate();
   state_machine_.NotifyReadyToActivate();
+  if (source_frame_number != -1) {
+    if (ready_to_activate_time_.empty() ||
+        ready_to_activate_time_.back().first != (unsigned)source_frame_number) {

[brianderson, 2017/04/17 23:28:50]

static_cast, then lgtm.

[panicker, 2017/04/17 23:32:19]

Done.

+      // Note the activate source-frame and timestamp
+      ready_to_activate_time_.emplace_back(source_frame_number,
+                                           base::TimeTicks::Now());
+    }
+  }
   ProcessScheduledActions();
 }
 
 void Scheduler::NotifyReadyToDraw() {
   // Future work might still needed for crbug.com/352894.
   state_machine_.NotifyReadyToDraw();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetBeginFrameSource(BeginFrameSource* source) {
@@ skipping 496 matching lines @@
 
 void Scheduler::ProcessScheduledActions() {
   // Do not perform actions during compositor shutdown.
   if (stopped_)
     return;
 
   // We do not allow ProcessScheduledActions to be recursive.
   // The top-level call will iteratively execute the next action for us anyway.
   if (inside_process_scheduled_actions_)
     return;
-
   base::AutoReset<bool> mark_inside(&inside_process_scheduled_actions_, true);
 
   SchedulerStateMachine::Action action;
   do {
     action = state_machine_.NextAction();
     TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                  "SchedulerStateMachine", "state", AsValue());
     base::AutoReset<SchedulerStateMachine::Action> mark_inside_action(
         &inside_action_, action);
     switch (action) {
       case SchedulerStateMachine::ACTION_NONE:
         break;
       case SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME:
         compositor_timing_history_->WillBeginMainFrame(
             begin_main_frame_args_.on_critical_path,
             begin_main_frame_args_.frame_time);
         state_machine_.WillSendBeginMainFrame();
         // TODO(brianderson): Pass begin_main_frame_args_ directly to client.
+        begin_main_frame_args_.ready_to_activate_time =
+            std::move(ready_to_activate_time_);
+        ready_to_activate_time_.clear();
         client_->ScheduledActionSendBeginMainFrame(begin_main_frame_args_);
         break;
       case SchedulerStateMachine::ACTION_COMMIT: {
         bool commit_has_no_updates = false;
         state_machine_.WillCommit(commit_has_no_updates);
         client_->ScheduledActionCommit();
         break;
       }
       case SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE:
         compositor_timing_history_->WillActivate();
@@ skipping 159 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