[throughput] Notify trackers when commit happens.

Notify the trackers when a begin-main-frame processing is complete, so
that the tracker can verify (with DCHECKs) that it is notified of the
events in a well-defined and expected sequence. At the moment, there
are synthesized 'begin main frame' notifications to the trackers that
prohibit the DCHECK()s to be added, but we will be turning those on in
follow up CLs.

BUG=1021963

Change-Id: I01e8bb2d869a1707b6a1b412fdab0cadfde12255
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1995461
Commit-Queue: Xida Chen <xidachen@chromium.org>
Reviewed-by: Xida Chen <xidachen@chromium.org>
Cr-Commit-Position: refs/heads/master@{#732238}

cc/metrics/frame_sequence_tracker.cc

@@ -293,6 +293,12 @@ void FrameSequenceTrackerCollection::NotifyBeginMainFrame(
     tracker.second->ReportBeginMainFrame(args);
 }
 
+void FrameSequenceTrackerCollection::NotifyMainFrameProcessed(
+    const viz::BeginFrameArgs& args) {
+  for (auto& tracker : frame_trackers_)
+    tracker.second->ReportMainFrameProcessed(args);
+}
+
 void FrameSequenceTrackerCollection::NotifyImplFrameCausedNoDamage(
     const viz::BeginFrameAck& ack) {
   for (auto& tracker : frame_trackers_) {
@@ -490,15 +496,42 @@ void FrameSequenceTracker::ReportBeginMainFrame(
   }
 #endif
 
+  // TODO(sad, xidachen): This DCHECK needs to be turned on, but the synthesized
+  // BeginMainFrame notifications from LayerTreeHostImpl needs to be removed
+  // first.
+  // DCHECK_EQ(awaiting_main_response_sequence_, 0u) << TRACKER_DCHECK_MSG;
+  awaiting_main_response_sequence_ = args.frame_id.sequence_number;
+
   UpdateTrackedFrameData(&begin_main_frame_data_, args.frame_id.source_id,
                          args.frame_id.sequence_number);
   if (!first_received_main_sequence_ ||
-      first_received_main_sequence_ <= last_no_main_damage_sequence_)
+      first_received_main_sequence_ <= last_no_main_damage_sequence_) {
     first_received_main_sequence_ = args.frame_id.sequence_number;
+  }
   main_throughput().frames_expected +=
       begin_main_frame_data_.previous_sequence_delta;
 }
 
+void FrameSequenceTracker::ReportMainFrameProcessed(
+    const viz::BeginFrameArgs& args) {
+  if (termination_status_ != TerminationStatus::kActive)
+    return;
+
+  if (ShouldIgnoreBeginFrameSource(args.frame_id.source_id))
+    return;
+
+  TRACKER_TRACE_STREAM << "E(" << args.frame_id.sequence_number << ")";
+  if (first_received_main_sequence_ &&
+      args.frame_id.sequence_number >= first_received_main_sequence_) {
+    // TODO(sad, xidachen): This DCHECK needs to be turned on, but the
+    // synthesized BeginMainFrame notifications from LayerTreeHostImpl needs to
+    // be removed first.
+    // DCHECK_EQ(awaiting_main_response_sequence_,
+    //           args.frame_id.sequence_number) << TRACKER_DCHECK_MSG;
+    awaiting_main_response_sequence_ = 0;
+  }
+}
+
 void FrameSequenceTracker::ReportSubmitFrame(
     uint32_t frame_token,
     bool has_missing_content,
@@ -729,6 +762,13 @@ void FrameSequenceTracker::ReportMainFrameCausedNoDamage(
   if (last_no_main_damage_sequence_ == args.frame_id.sequence_number)
     return;
 
+  // TODO(sad, xidachen): This DCHECK needs to be turned on, but the synthesized
+  // BeginMainFrame notifications from LayerTreeHostImpl needs to be removed
+  // first.
+  // DCHECK_EQ(awaiting_main_response_sequence_, args.frame_id.sequence_number)
+  //    << TRACKER_DCHECK_MSG;
+  awaiting_main_response_sequence_ = 0;
+
   DCHECK_GT(main_throughput().frames_expected, 0u) << TRACKER_DCHECK_MSG;
   DCHECK_GT(main_throughput().frames_expected,
             main_throughput().frames_produced)

cc/metrics/frame_sequence_tracker.h

@@ -157,6 +157,7 @@ class CC_EXPORT FrameSequenceTrackerCollection {
   // Notifies all trackers of various events.
   void NotifyBeginImplFrame(const viz::BeginFrameArgs& args);
   void NotifyBeginMainFrame(const viz::BeginFrameArgs& args);
+  void NotifyMainFrameProcessed(const viz::BeginFrameArgs& args);
   void NotifyImplFrameCausedNoDamage(const viz::BeginFrameAck& ack);
   void NotifyMainFrameCausedNoDamage(const viz::BeginFrameArgs& args);
   void NotifyPauseFrameProduction();
@@ -236,6 +237,8 @@ class CC_EXPORT FrameSequenceTracker {
   // thread.
   void ReportBeginMainFrame(const viz::BeginFrameArgs& args);
 
+  void ReportMainFrameProcessed(const viz::BeginFrameArgs& args);
+
   // Notifies the tracker when the compositor submits a CompositorFrame.
   // |origin_args| represents the BeginFrameArgs that triggered the update from
   // the main-thread.
@@ -362,6 +365,9 @@ class CC_EXPORT FrameSequenceTracker {
   // This is used to decide when to terminate this FrameSequenceTracker object.
   uint32_t last_submitted_frame_ = 0;
 
+  // Keeps track of the begin-main-frame that needs to be processed next.
+  uint64_t awaiting_main_response_sequence_ = 0;
+
   // Keeps track of the last sequence-number that produced a frame from the
   // main-thread.
   uint64_t last_submitted_main_sequence_ = 0;

cc/test/layer_tree_test.cc

@@ -212,8 +212,8 @@ class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
     test_hooks_->BeginMainFrameAbortedOnThread(this, reason);
   }
 
-  void ReadyToCommit() override {
-    LayerTreeHostImpl::ReadyToCommit();
+  void ReadyToCommit(const viz::BeginFrameArgs& commit_args) override {
+    LayerTreeHostImpl::ReadyToCommit(commit_args);
     test_hooks_->ReadyToCommitOnThread(this);
   }
 

cc/trees/layer_tree_host_impl.cc

@@ -375,6 +375,8 @@ void LayerTreeHostImpl::BeginMainFrameAborted(
   if (reason == CommitEarlyOutReason::ABORTED_NOT_VISIBLE ||
       reason == CommitEarlyOutReason::FINISHED_NO_UPDATES) {
     frame_trackers_.NotifyMainFrameCausedNoDamage(args);
+  } else {
+    frame_trackers_.NotifyMainFrameProcessed(args);
   }
 
   // If the begin frame data was handled, then scroll and scale set was applied
@@ -391,6 +393,10 @@ void LayerTreeHostImpl::BeginMainFrameAborted(
   }
 }
 
+void LayerTreeHostImpl::ReadyToCommit(const viz::BeginFrameArgs& commit_args) {
+  frame_trackers_.NotifyMainFrameProcessed(commit_args);
+}
+
 void LayerTreeHostImpl::BeginCommit() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::BeginCommit");
 

cc/trees/layer_tree_host_impl.h

@@ -341,7 +341,7 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler,
       CommitEarlyOutReason reason,
       std::vector<std::unique_ptr<SwapPromise>> swap_promises,
       const viz::BeginFrameArgs& args);
-  virtual void ReadyToCommit() {}  // For tests.
+  virtual void ReadyToCommit(const viz::BeginFrameArgs& commit_args);
   virtual void BeginCommit();
   virtual void CommitComplete();
   virtual void UpdateAnimationState(bool start_ready_animations);

cc/trees/proxy_impl.cc

@@ -270,7 +270,8 @@ void ProxyImpl::NotifyReadyToCommitOnImpl(
   // But, we can avoid a PostTask in here.
   scheduler_->NotifyBeginMainFrameStarted(main_thread_start_time);
 
-  host_impl_->ReadyToCommit();
+  host_impl_->ReadyToCommit(
+      scheduler_->last_dispatched_begin_main_frame_args());
 
   commit_completion_event_ =
       std::make_unique<ScopedCompletionEvent>(completion);

cc/trees/single_thread_proxy.cc

@@ -174,7 +174,7 @@ void SingleThreadProxy::SetNeedsUpdateLayers() {
   SetNeedsCommit();
 }
 
-void SingleThreadProxy::DoCommit() {
+void SingleThreadProxy::DoCommit(const viz::BeginFrameArgs& commit_args) {
   TRACE_EVENT0("cc", "SingleThreadProxy::DoCommit");
   DCHECK(task_runner_provider_->IsMainThread());
 
@@ -187,7 +187,7 @@ void SingleThreadProxy::DoCommit() {
     DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_);
     DebugScopedSetImplThread impl(task_runner_provider_);
 
-    host_impl_->ReadyToCommit();
+    host_impl_->ReadyToCommit(commit_args);
     host_impl_->BeginCommit();
 
     if (host_impl_->EvictedUIResourcesExist())
@@ -595,7 +595,7 @@ void SingleThreadProxy::CompositeImmediately(base::TimeTicks frame_begin_time,
     DoBeginMainFrame(begin_frame_args);
     commit_requested_ = false;
     DoPainting();
-    DoCommit();
+    DoCommit(begin_frame_args);
 
     DCHECK_EQ(
         0u,
@@ -900,7 +900,7 @@ DrawResult SingleThreadProxy::ScheduledActionDrawForced() {
 
 void SingleThreadProxy::ScheduledActionCommit() {
   DebugScopedSetMainThread main(task_runner_provider_);
-  DoCommit();
+  DoCommit(scheduler_on_impl_thread_->last_dispatched_begin_main_frame_args());
 }
 
 void SingleThreadProxy::ScheduledActionActivateSyncTree() {

cc/trees/single_thread_proxy.h

@@ -153,7 +153,7 @@ class CC_EXPORT SingleThreadProxy : public Proxy,
   void BeginMainFrameAbortedOnImplThread(CommitEarlyOutReason reason);
   void DoBeginMainFrame(const viz::BeginFrameArgs& begin_frame_args);
   void DoPainting();
-  void DoCommit();
+  void DoCommit(const viz::BeginFrameArgs& commit_args);
   DrawResult DoComposite(LayerTreeHostImpl::FrameData* frame);
   void DoSwap();
   void DidCommitAndDrawFrame();