Add duration estimation data to RenderingStats.

cc/trees/thread_proxy.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/trees/thread_proxy.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 987 matching lines @@
   // Delay this step until afer the main thread has been released as it's
   // often a good bit of work to update the tree and prepare the new frame.
   impl().layer_tree_host_impl->CommitComplete();
 
   SetInputThrottledUntilCommitOnImplThread(false);
 
   UpdateBackgroundAnimateTicking();
 
   impl().next_frame_is_newly_committed_frame = true;
 
-  impl().timing_history.DidCommit();
+  // Compute the estimate before we add the new duration so we can compare the
+  // estimated duration for this frame to the actual value.
+  base::TimeDelta begin_main_frame_to_commit_duration_estimate =
+      BeginMainFrameToCommitDurationEstimate();
+  base::TimeDelta begin_main_frame_to_commit_duration =
+      impl().timing_history.DidCommit();
+  impl()
+      .layer_tree_host_impl->rendering_stats_instrumentation()

[danakj, 2014/07/11 18:16:18]

I don't think ThreadProxy should be reaching through LTHI to the renderering
stats instrumentation. Can we make these calls from LTHI methods?

[ernstm, 2014/07/14 13:12:38]

ThreadProxy could access RenderingStatsInstrumentation through LayerTreeHost.

[Dominik Grewe, 2014/07/14 13:37:52]

As far as I understand, this method is always running on the compositor thread
(see DCHECK above), so we can't access LayerTreeHost.

I've added AddDrawDurationEstimate etc methods to LTHI so we can call into those
methods from ThreadProxy without exposing rendering_stats_instrumentation. Dana,
is this what you had in mind?

[ernstm, 2014/07/14 14:05:26]

I liked the version that exposes rendering_stats_instrumentation on LTHI a bit
better. rendering_stats_instrumentation is kind of global in cc already, because
it needs to accumulate stats from many places (similar to tracing for all of
Chrome). Dana, why would you prefer to not expose it on LTHI?

+      ->AddBeginMainFrameToCommitDuration(
+          begin_main_frame_to_commit_duration,
+          begin_main_frame_to_commit_duration_estimate);
 }
 
 void ThreadProxy::ScheduledActionUpdateVisibleTiles() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionUpdateVisibleTiles");
   DCHECK(IsImplThread());
   impl().layer_tree_host_impl->UpdateVisibleTiles();
 }
 
 void ThreadProxy::ScheduledActionActivatePendingTree() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionActivatePendingTree");
@@ skipping 111 matching lines @@
     UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDurationUnderestimate",
                                draw_duration_underestimate,
                                base::TimeDelta::FromMilliseconds(1),
                                base::TimeDelta::FromMilliseconds(100),
                                50);
     UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDurationOverestimate",
                                draw_duration_overestimate,
                                base::TimeDelta::FromMilliseconds(1),
                                base::TimeDelta::FromMilliseconds(100),
                                50);
+
+    impl()
+        .layer_tree_host_impl->rendering_stats_instrumentation()
+        ->AddDrawDuration(draw_duration, draw_duration_estimate);
   }
 
   DCHECK_NE(INVALID_RESULT, result);
   return result;
 }
 
 void ThreadProxy::ScheduledActionManageTiles() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionManageTiles");
   DCHECK(impl().layer_tree_host_impl->settings().impl_side_painting);
   impl().layer_tree_host_impl->ManageTiles();
@@ skipping 276 matching lines @@
   if (impl().completion_event_for_commit_held_on_tree_activation) {
     TRACE_EVENT_INSTANT0(
         "cc", "ReleaseCommitbyActivation", TRACE_EVENT_SCOPE_THREAD);
     DCHECK(impl().layer_tree_host_impl->settings().impl_side_painting);
     impl().completion_event_for_commit_held_on_tree_activation->Signal();
     impl().completion_event_for_commit_held_on_tree_activation = NULL;
   }
 
   UpdateBackgroundAnimateTicking();
 
-  impl().timing_history.DidActivatePendingTree();
+  // Compute the estimate before we add the new duration so we can compare the
+  // estimated duration for this frame to the actual value.
+  base::TimeDelta commit_to_activate_duration_estimate =
+      CommitToActivateDurationEstimate();
+  base::TimeDelta commit_to_activate_duration =
+      impl().timing_history.DidActivatePendingTree();
+  impl()
+      .layer_tree_host_impl->rendering_stats_instrumentation()
+      ->AddCommitToActivateDuration(commit_to_activate_duration,
+                                    commit_to_activate_duration_estimate);
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc