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

cc/scheduler/compositor_timing_history.cc

 // Copyright 2014 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/compositor_timing_history.h"
 
 #include "base/metrics/histogram.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 
@@ skipping 20 matching lines @@
                                bool affects_estimate) = 0;
 };
 
 namespace {
 
 // Using the 90th percentile will disable latency recovery
 // if we are missing the deadline approximately ~6 times per
 // second.
 // TODO(brianderson): Fine tune the percentiles below.
 const size_t kDurationHistorySize = 60;
-const size_t kDrawsBeforeEstimatesAffected = 2;
 const double kBeginMainFrameToCommitEstimationPercentile = 90.0;
 const double kCommitToReadyToActivateEstimationPercentile = 90.0;
 const double kPrepareTilesEstimationPercentile = 90.0;
 const double kActivateEstimationPercentile = 90.0;
 const double kDrawEstimationPercentile = 90.0;
 
 const int kUmaDurationMinMicros = 1;
 const int64 kUmaDurationMaxMicros = 1 * base::Time::kMicrosecondsPerSecond;
 const size_t kUmaDurationBucketCount = 100;
 
@@ skipping 140 matching lines @@
                        base::TimeDelta estimate,
                        bool affects_estimate) override {}
 };
 
 }  // namespace
 
 CompositorTimingHistory::CompositorTimingHistory(
     UMACategory uma_category,
     RenderingStatsInstrumentation* rendering_stats_instrumentation)
     : enabled_(false),
-      draws_left_before_estimates_affected_(0),
       begin_main_frame_to_commit_duration_history_(kDurationHistorySize),
       commit_to_ready_to_activate_duration_history_(kDurationHistorySize),
       prepare_tiles_duration_history_(kDurationHistorySize),
       activate_duration_history_(kDurationHistorySize),
       draw_duration_history_(kDurationHistorySize),
       uma_reporter_(CreateUMAReporter(uma_category)),
       rendering_stats_instrumentation_(rendering_stats_instrumentation) {}
 
 CompositorTimingHistory::~CompositorTimingHistory() {
 }
@@ skipping 26 matching lines @@
   state->SetDouble("activate_estimate_ms",
                    ActivateDurationEstimate().InMillisecondsF());
   state->SetDouble("draw_estimate_ms",
                    DrawDurationEstimate().InMillisecondsF());
 }
 
 base::TimeTicks CompositorTimingHistory::Now() const {
   return base::TimeTicks::Now();
 }
 
-bool CompositorTimingHistory::AffectsEstimate() const {
-  return enabled_ && (draws_left_before_estimates_affected_ == 0);
-}
-
 void CompositorTimingHistory::SetRecordingEnabled(bool enabled) {
-  if (enabled == enabled_)
-    return;
-
   enabled_ = enabled;
-
-  if (enabled_)
-    draws_left_before_estimates_affected_ = kDrawsBeforeEstimatesAffected;
 }
 
 base::TimeDelta
 CompositorTimingHistory::BeginMainFrameToCommitDurationEstimate() const {
   return begin_main_frame_to_commit_duration_history_.Percentile(
       kBeginMainFrameToCommitEstimationPercentile);
 }
 
 base::TimeDelta
 CompositorTimingHistory::CommitToReadyToActivateDurationEstimate() const {
@@ skipping 29 matching lines @@
   commit_time_ = Now();
 
   base::TimeDelta begin_main_frame_to_commit_duration =
       commit_time_ - begin_main_frame_sent_time_;
 
   // Before adding the new data point to the timing history, see what we would
   // have predicted for this frame. This allows us to keep track of the accuracy
   // of our predictions.
   base::TimeDelta begin_main_frame_to_commit_estimate =
       BeginMainFrameToCommitDurationEstimate();
-
+  uma_reporter_->AddBeginMainFrameToCommitDuration(
+      begin_main_frame_to_commit_duration, begin_main_frame_to_commit_estimate,
+      enabled_);
   rendering_stats_instrumentation_->AddBeginMainFrameToCommitDuration(
       begin_main_frame_to_commit_duration, begin_main_frame_to_commit_estimate);
 
-  bool affects_estimate = AffectsEstimate();
-  uma_reporter_->AddBeginMainFrameToCommitDuration(
-      begin_main_frame_to_commit_duration, begin_main_frame_to_commit_estimate,
-      affects_estimate);
-  if (affects_estimate) {
+  if (enabled_) {
     begin_main_frame_to_commit_duration_history_.InsertSample(
         begin_main_frame_to_commit_duration);
   }
 
   begin_main_frame_sent_time_ = base::TimeTicks();
 }
 
 void CompositorTimingHistory::WillPrepareTiles() {
   DCHECK_EQ(base::TimeTicks(), start_prepare_tiles_time_);
   start_prepare_tiles_time_ = Now();
 }
 
 void CompositorTimingHistory::DidPrepareTiles() {
   DCHECK_NE(base::TimeTicks(), start_prepare_tiles_time_);
 
   base::TimeDelta prepare_tiles_duration = Now() - start_prepare_tiles_time_;
-
-  bool affects_estimate = AffectsEstimate();
   uma_reporter_->AddPrepareTilesDuration(
-      prepare_tiles_duration, PrepareTilesDurationEstimate(), affects_estimate);
-  if (affects_estimate)
+      prepare_tiles_duration, PrepareTilesDurationEstimate(), enabled_);
+  if (enabled_)
     prepare_tiles_duration_history_.InsertSample(prepare_tiles_duration);
 
   start_prepare_tiles_time_ = base::TimeTicks();
 }
 
 void CompositorTimingHistory::ReadyToActivate() {
   // We only care about the first ready to activate signal
   // after a commit.
   if (commit_time_ == base::TimeTicks())
     return;
 
   base::TimeDelta time_since_commit = Now() - commit_time_;
 
   // Before adding the new data point to the timing history, see what we would
   // have predicted for this frame. This allows us to keep track of the accuracy
   // of our predictions.
 
   base::TimeDelta commit_to_ready_to_activate_estimate =
       CommitToReadyToActivateDurationEstimate();
+  uma_reporter_->AddCommitToReadyToActivateDuration(
+      time_since_commit, commit_to_ready_to_activate_estimate, enabled_);
   rendering_stats_instrumentation_->AddCommitToActivateDuration(
       time_since_commit, commit_to_ready_to_activate_estimate);
 
-  bool affects_estimate = AffectsEstimate();
-  uma_reporter_->AddCommitToReadyToActivateDuration(
-      time_since_commit, commit_to_ready_to_activate_estimate,
-      affects_estimate);
-  if (affects_estimate) {
+  if (enabled_) {
     commit_to_ready_to_activate_duration_history_.InsertSample(
         time_since_commit);
   }
 
   commit_time_ = base::TimeTicks();
 }
 
 void CompositorTimingHistory::WillActivate() {
   DCHECK_EQ(base::TimeTicks(), start_activate_time_);
   start_activate_time_ = Now();
 }
 
 void CompositorTimingHistory::DidActivate() {
   DCHECK_NE(base::TimeTicks(), start_activate_time_);
   base::TimeDelta activate_duration = Now() - start_activate_time_;
 
-  bool affects_estimate = AffectsEstimate();
-  uma_reporter_->AddActivateDuration(
-      activate_duration, ActivateDurationEstimate(), affects_estimate);
-  if (affects_estimate)
+  uma_reporter_->AddActivateDuration(activate_duration,
+                                     ActivateDurationEstimate(), enabled_);
+  if (enabled_)
     activate_duration_history_.InsertSample(activate_duration);
 
   start_activate_time_ = base::TimeTicks();
 }
 
 void CompositorTimingHistory::WillDraw() {
   DCHECK_EQ(base::TimeTicks(), start_draw_time_);
   start_draw_time_ = Now();
 }
 
 void CompositorTimingHistory::DidDraw() {
   DCHECK_NE(base::TimeTicks(), start_draw_time_);
   base::TimeDelta draw_duration = Now() - start_draw_time_;
 
   // Before adding the new data point to the timing history, see what we would
   // have predicted for this frame. This allows us to keep track of the accuracy
   // of our predictions.
   base::TimeDelta draw_estimate = DrawDurationEstimate();
   rendering_stats_instrumentation_->AddDrawDuration(draw_duration,
                                                     draw_estimate);
 
-  bool affects_estimate = AffectsEstimate();
-  uma_reporter_->AddDrawDuration(draw_duration, draw_estimate,
-                                 affects_estimate);
-  if (affects_estimate)
+  uma_reporter_->AddDrawDuration(draw_duration, draw_estimate, enabled_);
+
+  if (enabled_) {
     draw_duration_history_.InsertSample(draw_duration);
-
-  if (draws_left_before_estimates_affected_ > 0)
-    draws_left_before_estimates_affected_--;
+  }
 
   start_draw_time_ = base::TimeTicks();
 }
 
 }  // namespace cc