cc: Move timing history to the Scheduler.

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"
 #include "base/bind.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/input/input_handler.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/swap_promise.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/scheduler/commit_earlyout_reason.h"
-#include "cc/scheduler/delay_based_time_source.h"
+#include "cc/scheduler/compositor_timing_history.h"
 #include "cc/scheduler/scheduler.h"
 #include "cc/trees/blocking_task_runner.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/scoped_abort_remaining_swap_promises.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 
 namespace cc {
 
 namespace {
@@ skipping 71 matching lines @@
       commit_completion_event(NULL),
       completion_event_for_commit_held_on_tree_activation(NULL),
       next_frame_is_newly_committed_frame(false),
       inside_draw(false),
       input_throttled_until_commit(false),
       smoothness_priority_expiration_notifier(
           proxy->ImplThreadTaskRunner(),
           base::Bind(&ThreadProxy::RenewTreePriority, base::Unretained(proxy)),
           base::TimeDelta::FromMilliseconds(
               kSmoothnessTakesPriorityExpirationDelay * 1000)),
-      timing_history(rendering_stats_instrumentation),
       external_begin_frame_source(external_begin_frame_source.Pass()),
+      rendering_stats_instrumentation(rendering_stats_instrumentation),
       weak_factory(proxy) {
 }
 
 ThreadProxy::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 ThreadProxy::~ThreadProxy() {
   TRACE_EVENT0("cc", "ThreadProxy::~ThreadProxy");
   DCHECK(IsMainThread());
   DCHECK(!main().started);
 }
@@ skipping 531 matching lines @@
   // main_frame_before_activation_enabled is set, since we might run this code
   // twice before recording a duration. crbug.com/469824
   impl().last_begin_main_frame_args = begin_main_frame_state->begin_frame_args;
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::BeginMainFrame,
                  main_thread_weak_ptr_,
                  base::Passed(&begin_main_frame_state)));
   devtools_instrumentation::DidRequestMainThreadFrame(
       impl().layer_tree_host_id);
-  impl().timing_history.DidBeginMainFrame();
 }
 
 void ThreadProxy::SendBeginMainFrameNotExpectedSoon() {
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&ThreadProxy::BeginMainFrameNotExpectedSoon,
                             main_thread_weak_ptr_));
 }
 
 void ThreadProxy::BeginMainFrame(
     scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state) {
@@ skipping 234 matching lines @@
     impl().commit_completion_event = NULL;
   }
 
   // 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);
 
   impl().next_frame_is_newly_committed_frame = true;
-
-  impl().timing_history.DidCommit();
 }
 
 void ThreadProxy::ScheduledActionActivateSyncTree() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionActivateSyncTree");
   DCHECK(IsImplThread());
   impl().layer_tree_host_impl->ActivateSyncTree();
 }
 
 void ThreadProxy::ScheduledActionBeginOutputSurfaceCreation() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionBeginOutputSurfaceCreation");
   DCHECK(IsImplThread());
   Proxy::MainThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadProxy::RequestNewOutputSurface, main_thread_weak_ptr_));
 }
 
 DrawResult ThreadProxy::DrawSwapInternal(bool forced_draw) {
   TRACE_EVENT_SYNTHETIC_DELAY("cc.DrawAndSwap");
   DrawResult result;
 
   DCHECK(IsImplThread());
   DCHECK(impl().layer_tree_host_impl.get());
 
-  impl().timing_history.DidStartDrawing();
   base::AutoReset<bool> mark_inside(&impl().inside_draw, true);
 
   if (impl().layer_tree_host_impl->pending_tree()) {
     bool update_lcd_text = false;
     impl().layer_tree_host_impl->pending_tree()->UpdateDrawProperties(
         update_lcd_text);
   }
 
   // This method is called on a forced draw, regardless of whether we are able
   // to produce a frame, as the calling site on main thread is blocked until its
@@ skipping 31 matching lines @@
     impl().layer_tree_host_impl->SwapBuffers(frame);
 
   // Tell the main thread that the the newly-commited frame was drawn.
   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 (result == DRAW_SUCCESS)
-    impl().timing_history.DidFinishDrawing();
-
   DCHECK_NE(INVALID_RESULT, result);
   return result;
 }
 
 void ThreadProxy::ScheduledActionPrepareTiles() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionPrepareTiles");
   impl().layer_tree_host_impl->PrepareTiles();
 }
 
 DrawResult ThreadProxy::ScheduledActionDrawAndSwapIfPossible() {
@@ skipping 13 matching lines @@
   bool forced_draw = true;
   return DrawSwapInternal(forced_draw);
 }
 
 void ThreadProxy::ScheduledActionInvalidateOutputSurface() {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionInvalidateOutputSurface");
   DCHECK(impl().layer_tree_host_impl->output_surface());
   impl().layer_tree_host_impl->output_surface()->Invalidate();
 }
 
-base::TimeDelta ThreadProxy::DrawDurationEstimate() {
-  return impl().timing_history.DrawDurationEstimate();
-}
-
-base::TimeDelta ThreadProxy::BeginMainFrameToCommitDurationEstimate() {
-  return impl().timing_history.BeginMainFrameToCommitDurationEstimate();
-}
-
-base::TimeDelta ThreadProxy::CommitToActivateDurationEstimate() {
-  return impl().timing_history.CommitToActivateDurationEstimate();
-}
-
 void ThreadProxy::DidFinishImplFrame() {
   impl().layer_tree_host_impl->DidFinishImplFrame();
 }
 
 void ThreadProxy::SendBeginFramesToChildren(const BeginFrameArgs& args) {
   NOTREACHED() << "Only used by SingleThreadProxy";
 }
 
 void ThreadProxy::SetAuthoritativeVSyncInterval(
     const base::TimeDelta& interval) {
@@ skipping 14 matching lines @@
   TRACE_EVENT0("cc", "ThreadProxy::SetAnimationEvents");
   DCHECK(IsMainThread());
   layer_tree_host()->SetAnimationEvents(events.Pass());
 }
 
 void ThreadProxy::InitializeImplOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeImplOnImplThread");
   DCHECK(IsImplThread());
   impl().layer_tree_host_impl =
       layer_tree_host()->CreateLayerTreeHostImpl(this);
+
   SchedulerSettings scheduler_settings(
       layer_tree_host()->settings().ToSchedulerSettings());
+
+  scoped_ptr<CompositorTimingHistory> compositor_timing_history(
+      new CompositorTimingHistory(impl().rendering_stats_instrumentation));
+
   impl().scheduler = Scheduler::Create(
       this, scheduler_settings, impl().layer_tree_host_id,
-      ImplThreadTaskRunner(), impl().external_begin_frame_source.get());
+      ImplThreadTaskRunner(), impl().external_begin_frame_source.get(),
+      compositor_timing_history.Pass());
+
   impl().scheduler->SetVisible(impl().layer_tree_host_impl->visible());
   impl_thread_weak_ptr_ = impl().weak_factory.GetWeakPtr();
   completion->Signal();
 }
 
 void ThreadProxy::InitializeOutputSurfaceOnImplThread(
     scoped_ptr<OutputSurface> output_surface) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeOutputSurfaceOnImplThread");
   DCHECK(IsImplThread());
 
@@ skipping 142 matching lines @@
   TRACE_EVENT0("cc", "ThreadProxy::DidActivateSyncTreeOnImplThread");
   DCHECK(IsImplThread());
 
   if (impl().completion_event_for_commit_held_on_tree_activation) {
     TRACE_EVENT_INSTANT0(
         "cc", "ReleaseCommitbyActivation", TRACE_EVENT_SCOPE_THREAD);
     impl().completion_event_for_commit_held_on_tree_activation->Signal();
     impl().completion_event_for_commit_held_on_tree_activation = NULL;
   }
 
-  impl().timing_history.DidActivateSyncTree();
   impl().last_processed_begin_main_frame_args =
       impl().last_begin_main_frame_args;
 }
 
 void ThreadProxy::DidPrepareTiles() {
   DCHECK(IsImplThread());
   impl().scheduler->DidPrepareTiles();
 }
 
 void ThreadProxy::DidCompletePageScaleAnimationOnImplThread() {
@@ skipping 21 matching lines @@
 
 void ThreadProxy::PostFrameTimingEvents(
     scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
   DCHECK(IsMainThread());
   layer_tree_host()->RecordFrameTimingEvents(composite_events.Pass(),
                                              main_frame_events.Pass());
 }
 
 }  // namespace cc