cc: Abstract out proxy timing history

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 14 matching lines @@
 #include "cc/trees/blocking_task_runner.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "ui/gfx/frame_time.h"
 
 namespace {
 
 // Measured in seconds.
 const double kSmoothnessTakesPriorityExpirationDelay = 0.25;
 
-const size_t kDurationHistorySize = 60;
-const double kCommitAndActivationDurationEstimationPercentile = 50.0;
-const double kDrawDurationEstimationPercentile = 100.0;
-const int kDrawDurationEstimatePaddingInMicroseconds = 0;
-
 class SwapPromiseChecker {
  public:
   explicit SwapPromiseChecker(cc::LayerTreeHost* layer_tree_host)
       : layer_tree_host_(layer_tree_host) {}
 
   ~SwapPromiseChecker() {
     layer_tree_host_->BreakSwapPromises(cc::SwapPromise::COMMIT_FAILS);
   }
 
  private:
@@ skipping 75 matching lines @@
       begin_main_frame_sent_completion_event(NULL),
       readback_request(NULL),
       commit_completion_event(NULL),
       completion_event_for_commit_held_on_tree_activation(NULL),
       texture_acquisition_completion_event(NULL),
       next_frame_is_newly_committed_frame(false),
       inside_draw(false),
       input_throttled_until_commit(false),
       animations_frozen_until_next_draw(false),
       renew_tree_priority_pending(false),
-      draw_duration_history(kDurationHistorySize),
-      begin_main_frame_to_commit_duration_history(kDurationHistorySize),
-      commit_to_activate_duration_history(kDurationHistorySize),
       weak_factory(proxy) {}
 
 ThreadProxy::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 ThreadProxy::~ThreadProxy() {
   TRACE_EVENT0("cc", "ThreadProxy::~ThreadProxy");
   DCHECK(IsMainThread());
   DCHECK(!main().started);
 }
 
@@ skipping 632 matching lines @@
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::BeginMainFrame,
                  main_thread_weak_ptr_,
                  base::Passed(&begin_main_frame_state)));
 
   if (impl().begin_main_frame_sent_completion_event) {
     impl().begin_main_frame_sent_completion_event->Signal();
     impl().begin_main_frame_sent_completion_event = NULL;
   }
-  impl().begin_main_frame_sent_time = base::TimeTicks::HighResNow();
+  impl().timing_history.DidBeginMainFrame();
 }
 
 void ThreadProxy::BeginMainFrame(
     scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state) {
   TRACE_EVENT0("cc", "ThreadProxy::BeginMainFrame");
   TRACE_EVENT_SYNTHETIC_DELAY_BEGIN("cc.BeginMainFrame");
   DCHECK(IsMainThread());
 
   if (!layer_tree_host())
     return;
@@ skipping 285 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().commit_complete_time = base::TimeTicks::HighResNow();
-  impl().begin_main_frame_to_commit_duration_history.InsertSample(
-      impl().commit_complete_time - impl().begin_main_frame_sent_time);
+  impl().timing_history.DidCommit();
 
   // SetVisible kicks off the next scheduler action, so this must be last.
   impl().scheduler->SetVisible(impl().layer_tree_host_impl->visible());
 }
 
 void ThreadProxy::ScheduledActionUpdateVisibleTiles() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionUpdateVisibleTiles");
   DCHECK(IsImplThread());
   impl().layer_tree_host_impl->UpdateVisibleTiles();
 }
@@ skipping 16 matching lines @@
 DrawSwapReadbackResult ThreadProxy::DrawSwapReadbackInternal(
     bool forced_draw,
     bool swap_requested,
     bool readback_requested) {
   TRACE_EVENT_SYNTHETIC_DELAY("cc.DrawAndSwap");
   DrawSwapReadbackResult result;
 
   DCHECK(IsImplThread());
   DCHECK(impl().layer_tree_host_impl.get());
 
-  base::TimeTicks start_time = base::TimeTicks::HighResNow();
+  impl().timing_history.DidStartDrawing();
   base::TimeDelta draw_duration_estimate = DrawDurationEstimate();
   base::AutoReset<bool> mark_inside(&impl().inside_draw, true);
 
   // Advance our animations.
   base::TimeTicks monotonic_time;
   if (impl().animations_frozen_until_next_draw)
     monotonic_time = impl().animation_freeze_time;
   else
     monotonic_time = impl().layer_tree_host_impl->CurrentFrameTimeTicks();
 
@@ skipping 89 matching lines @@
   if (impl().next_frame_is_newly_committed_frame) {
     impl().next_frame_is_newly_committed_frame = false;
     Proxy::MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(&ThreadProxy::DidCommitAndDrawFrame, main_thread_weak_ptr_));
   }
 
   if (draw_frame) {
     CheckOutputSurfaceStatusOnImplThread();
 
-    base::TimeDelta draw_duration = base::TimeTicks::HighResNow() - start_time;
-    impl().draw_duration_history.InsertSample(draw_duration);
+    base::TimeDelta draw_duration = impl().timing_history.DidFinishDrawing();
+
     base::TimeDelta draw_duration_overestimate;
     base::TimeDelta draw_duration_underestimate;
     if (draw_duration > draw_duration_estimate)
       draw_duration_underestimate = draw_duration - draw_duration_estimate;
     else
       draw_duration_overestimate = draw_duration_estimate - draw_duration;
     UMA_HISTOGRAM_CUSTOM_TIMES("Renderer.DrawDuration",
                                draw_duration,
                                base::TimeDelta::FromMilliseconds(1),
                                base::TimeDelta::FromMilliseconds(100),
@@ skipping 86 matching lines @@
   return DrawSwapReadbackInternal(
       forced_draw, swap_requested, readback_requested);
 }
 
 void ThreadProxy::DidAnticipatedDrawTimeChange(base::TimeTicks time) {
   if (impl().current_resource_update_controller)
     impl().current_resource_update_controller->PerformMoreUpdates(time);
 }
 
 base::TimeDelta ThreadProxy::DrawDurationEstimate() {
-  base::TimeDelta historical_estimate = impl().draw_duration_history.Percentile(
-      kDrawDurationEstimationPercentile);
-  base::TimeDelta padding = base::TimeDelta::FromMicroseconds(
-      kDrawDurationEstimatePaddingInMicroseconds);
-  return historical_estimate + padding;
+  return impl().timing_history.DrawDurationEstimate();
 }
 
 base::TimeDelta ThreadProxy::BeginMainFrameToCommitDurationEstimate() {
-  return impl().begin_main_frame_to_commit_duration_history.Percentile(
-      kCommitAndActivationDurationEstimationPercentile);
+  return impl().timing_history.BeginMainFrameToCommitDurationEstimate();
 }
 
 base::TimeDelta ThreadProxy::CommitToActivateDurationEstimate() {
-  return impl().commit_to_activate_duration_history.Percentile(
-      kCommitAndActivationDurationEstimationPercentile);
+  return impl().timing_history.CommitToActivateDurationEstimate();
 }
 
 void ThreadProxy::PostBeginImplFrameDeadline(const base::Closure& closure,
                                              base::TimeTicks deadline) {
   base::TimeDelta delta = deadline - gfx::FrameTime::Now();
   if (delta <= base::TimeDelta())
     delta = base::TimeDelta();
   Proxy::ImplThreadTaskRunner()->PostDelayedTask(FROM_HERE, closure, delta);
 }
 
@@ skipping 324 matching lines @@
       !impl().layer_tree_host_impl->pending_tree()) {
     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().commit_to_activate_duration_history.InsertSample(
-      base::TimeTicks::HighResNow() - impl().commit_complete_time);
+  impl().timing_history.DidActivatePendingTree();
 }
 
 void ThreadProxy::DidManageTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidManageTiles();
 }
 
 }  // namespace cc