Terminate reporters which caused no damage

The reporters which caused no damage (Impl or Main) are terminated and
will not be reported to the compositor latency metrics.

Bug: chromium:1030304
Cq-Depend: chromium:1961074
Change-Id: I8cc4afe4b00f86b9f4893347d6ef76d8bf0126ad
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1992345Reviewed-by: Sadrul Chowdhury <sadrul@chromium.org>
Commit-Queue: Behdad Bakhshinategh <behdadb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#734613}

cc/metrics/compositor_frame_reporter.cc

@@ -175,6 +175,8 @@ CompositorFrameReporter::StageData::~StageData() = default;
 void CompositorFrameReporter::StartStage(
     CompositorFrameReporter::StageType stage_type,
     base::TimeTicks start_time) {
+  if (frame_termination_status_ != FrameTerminationStatus::kUnknown)
+    return;
   EndCurrentStage(start_time);
   if (stage_history_.empty()) {
     // Use first stage's start timestamp to ensure correct event nesting.
@@ -213,6 +215,11 @@ void CompositorFrameReporter::MissedSubmittedFrame() {
 void CompositorFrameReporter::TerminateFrame(
     FrameTerminationStatus termination_status,
     base::TimeTicks termination_time) {
+  // If the reporter is already terminated, (possibly as a result of no damage)
+  // then we don't need to do anything here, otherwise the reporter will be
+  // terminated.
+  if (frame_termination_status_ != FrameTerminationStatus::kUnknown)
+    return;
   frame_termination_status_ = termination_status;
   frame_termination_time_ = termination_time;
   EndCurrentStage(frame_termination_time_);

cc/metrics/compositor_frame_reporting_controller.cc

@@ -178,6 +178,18 @@ void CompositorFrameReportingController::DidSubmitCompositorFrame(
                                             std::move(submitted_reporter));
 }
 
+void CompositorFrameReportingController::DidNotProduceFrame(
+    const viz::BeginFrameId& id) {
+  for (auto& stage_reporter : reporters_) {
+    if (stage_reporter && stage_reporter->frame_id_ == id) {
+      stage_reporter->TerminateFrame(
+          CompositorFrameReporter::FrameTerminationStatus::kDidNotProduceFrame,
+          Now());
+      return;
+    }
+  }
+}
+
 void CompositorFrameReportingController::OnFinishImplFrame(
     const viz::BeginFrameId& id) {
   if (reporters_[PipelineStage::kBeginImplFrame]) {

cc/metrics/compositor_frame_reporting_controller.h

@@ -61,6 +61,7 @@ class CC_EXPORT CompositorFrameReportingController {
       uint32_t frame_token,
       const viz::BeginFrameId& current_frame_id,
       const viz::BeginFrameId& last_activated_frame_id);
+  virtual void DidNotProduceFrame(const viz::BeginFrameId& id);
   virtual void OnFinishImplFrame(const viz::BeginFrameId& id);
   virtual void DidPresentCompositorFrame(
       uint32_t frame_token,

cc/metrics/compositor_frame_reporting_controller_unittest.cc

@@ -249,6 +249,33 @@ TEST_F(CompositorFrameReportingControllerTest, ImplFrameCausedNoDamage) {
       "CompositorLatency.MissedFrame.BeginImplFrameToSendBeginMainFrame", 0);
 }
 
+TEST_F(CompositorFrameReportingControllerTest, MainFrameCausedNoDamage) {
+  base::HistogramTester histogram_tester;
+  viz::BeginFrameId current_id_1_ = viz::BeginFrameId(1, 1);
+  viz::BeginFrameId current_id_2_ = viz::BeginFrameId(1, 2);
+  viz::BeginFrameId current_id_3_ = viz::BeginFrameId(1, 3);
+
+  reporting_controller_.WillBeginImplFrame(current_id_1_);
+  reporting_controller_.WillBeginMainFrame(current_id_1_);
+  reporting_controller_.BeginMainFrameAborted(current_id_1_);
+  reporting_controller_.OnFinishImplFrame(current_id_1_);
+  reporting_controller_.DidNotProduceFrame(current_id_1_);
+
+  reporting_controller_.WillBeginImplFrame(current_id_2_);
+  reporting_controller_.WillBeginMainFrame(current_id_2_);
+  reporting_controller_.OnFinishImplFrame(current_id_2_);
+  reporting_controller_.BeginMainFrameAborted(current_id_2_);
+  reporting_controller_.DidNotProduceFrame(current_id_2_);
+
+  reporting_controller_.WillBeginImplFrame(current_id_3_);
+  reporting_controller_.WillBeginMainFrame(current_id_3_);
+
+  histogram_tester.ExpectTotalCount(
+      "CompositorLatency.MissedFrame.BeginImplFrameToSendBeginMainFrame", 0);
+  histogram_tester.ExpectTotalCount(
+      "CompositorLatency.MissedFrame.SendBeginMainFrameToCommit", 0);
+}
+
 TEST_F(CompositorFrameReportingControllerTest, MainFrameAborted) {
   base::HistogramTester histogram_tester;
 

cc/metrics/compositor_timing_history.cc

@@ -1075,6 +1075,10 @@ void CompositorTimingHistory::DidSubmitCompositorFrame(
   submit_start_time_ = Now();
 }
 
+void CompositorTimingHistory::DidNotProduceFrame(const viz::BeginFrameId& id) {
+  compositor_frame_reporting_controller_->DidNotProduceFrame(id);
+}
+
 void CompositorTimingHistory::DidReceiveCompositorFrameAck() {
   DCHECK_NE(base::TimeTicks(), submit_start_time_);
   base::TimeDelta submit_to_ack_duration = Now() - submit_start_time_;

cc/metrics/compositor_timing_history.h

@@ -99,6 +99,7 @@ class CC_EXPORT CompositorTimingHistory {
       uint32_t frame_token,
       const viz::BeginFrameId& current_frame_id,
       const viz::BeginFrameId& last_activated_frame_id);
+  void DidNotProduceFrame(const viz::BeginFrameId& id);
   void DidReceiveCompositorFrameAck();
   void DidPresentCompositorFrame(uint32_t frame_token,
                                  const viz::FrameTimingDetails& details);

cc/scheduler/scheduler.cc

@@ -602,6 +602,8 @@ void Scheduler::SendDidNotProduceFrame(const viz::BeginFrameArgs& args,
     return;
   last_begin_frame_ack_ = viz::BeginFrameAck(args, false /* has_damage */);
   client_->DidNotProduceFrame(last_begin_frame_ack_, reason);
+  if (reason == FrameSkippedReason::kNoDamage)
+    compositor_timing_history_->DidNotProduceFrame(args.frame_id);
 }
 
 // BeginImplFrame starts a compositor frame that will wait up until a deadline