Revert "cc: Don't record first two frames in CompositorTimingHistory"

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 260 matching lines @@
 
 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);
       devtools_instrumentation::NeedsBeginFrameChanged(layer_tree_host_id_,
                                                        true);
-      UpdateCompositorTimingHistoryRecordingEnabled();
     } else if (state_machine_.begin_impl_frame_state() ==
                SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE) {
       // Call SetNeedsBeginFrames(false) in between frames only.
       frame_source_->SetNeedsBeginFrames(false);
       client_->SendBeginMainFrameNotExpectedSoon();
       devtools_instrumentation::NeedsBeginFrameChanged(layer_tree_host_id_,
                                                        false);
-      UpdateCompositorTimingHistoryRecordingEnabled();
     }
   }
 
   PostBeginRetroFrameIfNeeded();
 }
 
 // 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.
@@ skipping 434 matching lines @@
       &frame_tracing_enabled);
   if (frame_tracing_enabled) {
     state->BeginDictionary("frame_source_");
     frame_source_->AsValueInto(state);
     state->EndDictionary();
   }
 
   state->BeginDictionary("scheduler_state");
   state->SetDouble("estimated_parent_draw_time_ms",
                    estimated_parent_draw_time_.InMillisecondsF());
+  state->SetBoolean("last_set_needs_begin_frame_",
+                    frame_source_->NeedsBeginFrames());
   state->SetInteger("begin_retro_frame_args",
                     static_cast<int>(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->SetString("inside_action",
                    SchedulerStateMachine::ActionToString(inside_action_));
 
   state->BeginDictionary("begin_impl_frame_args");
   begin_impl_frame_tracker_.AsValueInto(now, state);
   state->EndDictionary();
 
   state->SetString("begin_impl_frame_deadline_mode_",
                    SchedulerStateMachine::BeginImplFrameDeadlineModeToString(
                        begin_impl_frame_deadline_mode_));
   state->EndDictionary();
 
   state->BeginDictionary("compositor_timing_history");
   compositor_timing_history_->AsValueInto(state);
   state->EndDictionary();
 }
 
 void Scheduler::UpdateCompositorTimingHistoryRecordingEnabled() {
   compositor_timing_history_->SetRecordingEnabled(
-      state_machine_.HasInitializedOutputSurface() &&
-      state_machine_.visible() && frame_source_->NeedsBeginFrames());
+      state_machine_.HasInitializedOutputSurface() && state_machine_.visible());
 }
 
 bool Scheduler::ShouldRecoverMainLatency(const BeginFrameArgs& args) const {
   DCHECK(!settings_.using_synchronous_renderer_compositor);
 
   if (!state_machine_.main_thread_missed_last_deadline())
     return false;
 
   // When prioritizing impl thread latency, we currently put the
   // main thread in a high latency mode. Don't try to fight it.
@@ skipping 52 matching lines @@
 }
 
 bool Scheduler::IsBeginMainFrameSentOrStarted() const {
   return (state_machine_.begin_main_frame_state() ==
               SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT ||
           state_machine_.begin_main_frame_state() ==
               SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_STARTED);
 }
 
 }  // namespace cc