Add duration estimation data to RenderingStats.

cc/debug/rendering_stats_instrumentation.cc

 // Copyright 2013 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/debug/rendering_stats_instrumentation.h"
 
 namespace cc {
 
 // static
 scoped_ptr<RenderingStatsInstrumentation>
@@ skipping 121 matching lines @@
 
 void RenderingStatsInstrumentation::AddApproximatedVisibleContentArea(
     int64 area) {
   if (!record_rendering_stats_)
     return;
 
   base::AutoLock scoped_lock(lock_);
   impl_thread_rendering_stats_.approximated_visible_content_area += area;
 }
 
+void RenderingStatsInstrumentation::AddDrawDuration(
+    base::TimeDelta draw_duration,
+    base::TimeDelta draw_duration_estimate) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  // This should only be called once per frame.
+  DCHECK(impl_thread_rendering_stats_.draw_duration == base::TimeDelta());

[Dominik Grewe, 2014/07/02 14:43:22]

I added these DCHECKS because I thought we'd only call this once per frame. It
turns out they actually trigger though, so maybe I'm misunderstanding how this
works. Or is this a bug?

If we can't guarantee that we only get at most one call per frame, we could use
a list of values instead (summing them up doesn't make sense here).

[brianderson, 2014/07/02 22:39:29]

I think it has to do with the various draw early outs that might prevent the
stats from resetting. ThreadProxy::DrawSwapInternal always reaches the final
return, but LTHI::DrawLayers sometimes isn't even called by
ThreadProxy::DrawSwapInternal or LayerTreeHostImpl::DrawLayers can return early
if there is no damage.

[Dominik Grewe, 2014/07/03 13:16:38]

I see. Thanks for the clarification!

+  DCHECK(impl_thread_rendering_stats_.draw_duration_estimate ==
+         base::TimeDelta());
+  impl_thread_rendering_stats_.draw_duration = draw_duration;
+  impl_thread_rendering_stats_.draw_duration_estimate = draw_duration_estimate;
+}
+
+void RenderingStatsInstrumentation::AddBeginMainFrameToCommitDuration(
+    base::TimeDelta begin_main_frame_to_commit_duration,
+    base::TimeDelta begin_main_frame_to_commit_duration_estimate) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  // This should only be called once per frame.
+  DCHECK(impl_thread_rendering_stats_.begin_main_frame_to_commit_duration ==
+         base::TimeDelta());
+  DCHECK(impl_thread_rendering_stats_
+             .begin_main_frame_to_commit_duration_estimate ==
+         base::TimeDelta());
+  impl_thread_rendering_stats_.begin_main_frame_to_commit_duration =
+      begin_main_frame_to_commit_duration;
+  impl_thread_rendering_stats_.begin_main_frame_to_commit_duration_estimate =
+      begin_main_frame_to_commit_duration_estimate;
+}
+
+void RenderingStatsInstrumentation::AddCommitToActivateDuration(
+    base::TimeDelta commit_to_activate_duration,
+    base::TimeDelta commit_to_activate_duration_estimate) {
+  if (!record_rendering_stats_)
+    return;
+
+  base::AutoLock scoped_lock(lock_);
+  // This should only be called once per frame.
+  DCHECK(impl_thread_rendering_stats_.commit_to_activate_duration ==
+         base::TimeDelta());
+  DCHECK(impl_thread_rendering_stats_.commit_to_activate_duration_estimate ==
+         base::TimeDelta());
+  impl_thread_rendering_stats_.commit_to_activate_duration =
+      commit_to_activate_duration;
+  impl_thread_rendering_stats_.commit_to_activate_duration_estimate =
+      commit_to_activate_duration_estimate;
+}
+
 }  // namespace cc