cc: Measure compositor timing with finer granularity

cc/scheduler/scheduler_unittest.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/scheduler/scheduler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
+#include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "cc/test/scheduler_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #define EXPECT_ACTION(action, client, action_index, expected_num_actions)  \
   do {                                                                     \
     EXPECT_EQ(expected_num_actions, client->num_actions_());               \
     if (action_index >= 0) {                                               \
@@ skipping 99 matching lines @@
 
       if (automatic_swap_ack_)
         scheduler_->DidSwapBuffersComplete();
     }
     return result;
   }
   DrawResult ScheduledActionDrawAndSwapForced() override {
     PushAction("ScheduledActionDrawAndSwapForced");
     return DRAW_SUCCESS;
   }
-  void ScheduledActionCommit() override { PushAction("ScheduledActionCommit"); }
+  void ScheduledActionCommit() override {
+    PushAction("ScheduledActionCommit");
+    scheduler_->DidCommit();
+  }
   void ScheduledActionActivateSyncTree() override {
     PushAction("ScheduledActionActivateSyncTree");
   }
   void ScheduledActionBeginOutputSurfaceCreation() override {
     PushAction("ScheduledActionBeginOutputSurfaceCreation");
   }
   void ScheduledActionPrepareTiles() override {
     PushAction("ScheduledActionPrepareTiles");
+    scheduler_->WillPrepareTiles();
+    scheduler_->DidPrepareTiles();

[picksi, 2015/06/19 13:04:28]

You seem to be measuring nothing here?

[brianderson, 2015/06/19 17:24:27]

Every WillPrepareTiles must be followed by a DidPrepareTiles to avoid the DCHECK
in CompositorTimingHistory.

The scheduler tests themselves fake the estimations, so the actual timing
doesn't matter.

   }
   void ScheduledActionInvalidateOutputSurface() override {
     actions_.push_back("ScheduledActionInvalidateOutputSurface");
     states_.push_back(scheduler_->AsValue());
   }
   void DidAnticipatedDrawTimeChange(base::TimeTicks) override {
     if (log_anticipated_draw_time_change_)
       PushAction("DidAnticipatedDrawTimeChange");
   }
-  base::TimeDelta DrawDurationEstimate() override { return base::TimeDelta(); }
-  base::TimeDelta BeginMainFrameToCommitDurationEstimate() override {
-    return base::TimeDelta();
-  }
-  base::TimeDelta CommitToActivateDurationEstimate() override {
-    return base::TimeDelta();
-  }
 
   void SendBeginFramesToChildren(const BeginFrameArgs& args) override {
     begin_frame_args_sent_to_children_ = args;
   }
 
   void SendBeginMainFrameNotExpectedSoon() override {
     PushAction("SendBeginMainFrameNotExpectedSoon");
   }
 
   base::Callback<bool(void)> ImplFrameDeadlinePending(bool state) {
@@ skipping 26 matching lines @@
   int num_draws_;
   bool log_anticipated_draw_time_change_;
   BeginFrameArgs begin_frame_args_sent_to_children_;
   base::TimeTicks posted_begin_impl_frame_deadline_;
   std::vector<const char*> actions_;
   std::vector<scoped_refptr<base::trace_event::ConvertableToTraceFormat>>
       states_;
   TestScheduler* scheduler_;
 };
 
-class SchedulerClientWithFixedEstimates : public FakeSchedulerClient {
- public:
-  SchedulerClientWithFixedEstimates(
-      base::TimeDelta draw_duration,
-      base::TimeDelta begin_main_frame_to_commit_duration,
-      base::TimeDelta commit_to_activate_duration)
-      : draw_duration_(draw_duration),
-        begin_main_frame_to_commit_duration_(
-            begin_main_frame_to_commit_duration),
-        commit_to_activate_duration_(commit_to_activate_duration) {}
-
-  base::TimeDelta DrawDurationEstimate() override { return draw_duration_; }
-  base::TimeDelta BeginMainFrameToCommitDurationEstimate() override {
-    return begin_main_frame_to_commit_duration_;
-  }
-  base::TimeDelta CommitToActivateDurationEstimate() override {
-    return commit_to_activate_duration_;
-  }
-
- private:
-  base::TimeDelta draw_duration_;
-  base::TimeDelta begin_main_frame_to_commit_duration_;
-  base::TimeDelta commit_to_activate_duration_;
-};
-
 class FakeExternalBeginFrameSource : public BeginFrameSourceBase {
  public:
   explicit FakeExternalBeginFrameSource(FakeSchedulerClient* client)
       : client_(client) {}
   ~FakeExternalBeginFrameSource() override {}
 
   void OnNeedsBeginFramesChange(bool needs_begin_frames) override {
     if (needs_begin_frames) {
       client_->PushAction("SetNeedsBeginFrames(true)");
     } else {
@@ skipping 27 matching lines @@
 
  protected:
   TestScheduler* CreateScheduler() {
     scoped_ptr<FakeExternalBeginFrameSource> fake_external_begin_frame_source;
     if (scheduler_settings_.use_external_begin_frame_source) {
       fake_external_begin_frame_source.reset(
           new FakeExternalBeginFrameSource(client_.get()));
       fake_external_begin_frame_source_ =
           fake_external_begin_frame_source.get();
     }
+    rendering_stats_instrumentation_ = RenderingStatsInstrumentation::Create();
     scheduler_ = TestScheduler::Create(now_src_.get(), client_.get(),
                                        scheduler_settings_, 0, task_runner_,
-                                       fake_external_begin_frame_source.Pass());
+                                       fake_external_begin_frame_source.Pass(),
+                                       rendering_stats_instrumentation_.get());
     DCHECK(scheduler_);
     client_->set_scheduler(scheduler_.get());
     return scheduler_.get();
   }
 
   void CreateSchedulerAndInitSurface() {
     CreateScheduler();
     EXPECT_SCOPED(InitializeOutputSurfaceAndFirstCommit());
   }
 
@@ skipping 40 matching lines @@
     scheduler_->SetNeedsCommit();
     EXPECT_TRUE(client_->needs_begin_frames());
     EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
     client_->Reset();
 
     {
       SCOPED_TRACE("Do first frame to commit after initialize.");
       AdvanceFrame();
 
       scheduler_->NotifyBeginMainFrameStarted();
-      scheduler_->NotifyReadyToCommitThenActivateIfNeeded();
+      scheduler_->NotifyReadyToCommit();
+      scheduler_->NotifyReadyToActivate();
 
       EXPECT_FALSE(scheduler_->CommitPending());
 
       if (scheduler_settings_.using_synchronous_renderer_compositor) {
         scheduler_->SetNeedsRedraw();
         scheduler_->OnDrawForOutputSurface();
       } else {
         // Run the posted deadline task.
         EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
         task_runner_->RunTasksWhile(client_->ImplFrameDeadlinePending(true));
@@ skipping 75 matching lines @@
   void BeginFramesNotFromClient_SwapThrottled(
       bool use_external_begin_frame_source,
       bool throttle_frame_production);
 
   scoped_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   FakeExternalBeginFrameSource* fake_external_begin_frame_source_;
   SchedulerSettings scheduler_settings_;
   scoped_ptr<FakeSchedulerClient> client_;
   scoped_ptr<TestScheduler> scheduler_;
+  scoped_ptr<RenderingStatsInstrumentation> rendering_stats_instrumentation_;
 };
 
 TEST_F(SchedulerTest, InitializeOutputSurfaceDoesNotBeginImplFrame) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(false);
   scheduler_->SetCanStart();
   scheduler_->SetVisible(true);
   scheduler_->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_);
@@ skipping 31 matching lines @@
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client_);
   EXPECT_TRUE(client_->needs_begin_frames());
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(client_->begin_frame_is_sent_to_children());
 }
 
 TEST_F(SchedulerTest, SendBeginFramesToChildrenDeadlineNotAdjusted) {
   // Set up client with specified estimates.
-  SchedulerClientWithFixedEstimates* client =
-      new SchedulerClientWithFixedEstimates(
-          base::TimeDelta::FromMilliseconds(1),
-          base::TimeDelta::FromMilliseconds(2),
-          base::TimeDelta::FromMilliseconds(4));
   scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(make_scoped_ptr(client).Pass(), true);
+  SetUpScheduler(true);
+  scheduler_->SetDrawDurationEstimate(base::TimeDelta::FromMilliseconds(1));
+  scheduler_->SetBeginMainFrameToCommitDurationEstimate(
+      base::TimeDelta::FromMilliseconds(2));
+  scheduler_->SetPrepareTilesToReadyToActivateDurationEstimate(
+      base::TimeDelta::FromMilliseconds(4));
 
   EXPECT_FALSE(client_->needs_begin_frames());
   scheduler_->SetChildrenNeedBeginFrames(true);
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client_);
   EXPECT_TRUE(client_->needs_begin_frames());
 
   client_->Reset();
 
   BeginFrameArgs frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src());
@@ skipping 234 matching lines @@
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_FALSE(client_->needs_begin_frames());
   client_->Reset();
 }
 
 class SchedulerClientThatsetNeedsDrawInsideDraw : public FakeSchedulerClient {
  public:
   SchedulerClientThatsetNeedsDrawInsideDraw()
       : FakeSchedulerClient(), request_redraws_(false) {}
 
-  void ScheduledActionSendBeginMainFrame() override {}
-
   void SetRequestRedrawsInsideDraw(bool enable) { request_redraws_ = enable; }
 
   DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     // Only SetNeedsRedraw the first time this is called
     if (request_redraws_) {
       scheduler_->SetNeedsRedraw();
     }
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
   DrawResult ScheduledActionDrawAndSwapForced() override {
     NOTREACHED();
     return DRAW_SUCCESS;
   }
 
-  void ScheduledActionCommit() override {}
-  void DidAnticipatedDrawTimeChange(base::TimeTicks) override {}
-
  private:
   bool request_redraws_;
 };
 
 // Tests for two different situations:
 // 1. the scheduler dropping SetNeedsRedraw requests that happen inside
 //    a ScheduledActionDrawAndSwap
 // 2. the scheduler drawing twice inside a single tick
 TEST_F(SchedulerTest, RequestRedrawInsideDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw* client =
@@ skipping 74 matching lines @@
   EXPECT_TRUE(scheduler_->CommitPending());
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_TRUE(client->needs_begin_frames());
 }
 
 class SchedulerClientThatSetNeedsCommitInsideDraw : public FakeSchedulerClient {
  public:
   SchedulerClientThatSetNeedsCommitInsideDraw()
       : set_needs_commit_on_next_draw_(false) {}
 
-  void ScheduledActionSendBeginMainFrame() override {}
   DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     // Only SetNeedsCommit the first time this is called
     if (set_needs_commit_on_next_draw_) {
       scheduler_->SetNeedsCommit();
       set_needs_commit_on_next_draw_ = false;
     }
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
   DrawResult ScheduledActionDrawAndSwapForced() override {
     NOTREACHED();
     return DRAW_SUCCESS;
   }
 
-  void ScheduledActionCommit() override {}
-  void DidAnticipatedDrawTimeChange(base::TimeTicks) override {}
-
   void SetNeedsCommitOnNextDraw() { set_needs_commit_on_next_draw_ = true; }
 
  private:
   bool set_needs_commit_on_next_draw_;
 };
 
 // Tests for the scheduler infinite-looping on SetNeedsCommit requests that
 // happen inside a ScheduledActionDrawAndSwap
 TEST_F(SchedulerTest, RequestCommitInsideDraw) {
   SchedulerClientThatSetNeedsCommitInsideDraw* client =
@@ skipping 231 matching lines @@
   // again.
   scheduler_->SetNeedsPrepareTiles();
   scheduler_->SetNeedsRedraw();
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
 
   EXPECT_TRUE(scheduler_->PrepareTilesPending());
+  scheduler_->WillPrepareTiles();
   scheduler_->DidPrepareTiles();  // An explicit PrepareTiles.
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
 
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client_->num_draws());
   EXPECT_TRUE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_FALSE(client_->HasAction("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
@@ skipping 11 matching lines @@
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client_->num_draws());
   EXPECT_TRUE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_TRUE(client_->HasAction("ScheduledActionPrepareTiles"));
   EXPECT_LT(client_->ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
             client_->ActionIndex("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
-  scheduler_->DidPrepareTiles();  // Corresponds to ScheduledActionPrepareTiles
 
   // If we get another DidPrepareTiles within the same frame, we should
   // not PrepareTiles on the next frame.
+  scheduler_->WillPrepareTiles();
   scheduler_->DidPrepareTiles();  // An explicit PrepareTiles.
   scheduler_->SetNeedsPrepareTiles();
   scheduler_->SetNeedsRedraw();
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
 
   EXPECT_TRUE(scheduler_->PrepareTilesPending());
 
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client_->num_draws());
   EXPECT_TRUE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_FALSE(client_->HasAction("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
 
   // If we get another DidPrepareTiles, we should not PrepareTiles on the next
   // frame. This verifies we don't alternate calling PrepareTiles once and
   // twice.
   EXPECT_TRUE(scheduler_->PrepareTilesPending());
+  scheduler_->WillPrepareTiles();
   scheduler_->DidPrepareTiles();  // An explicit PrepareTiles.
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   scheduler_->SetNeedsPrepareTiles();
   scheduler_->SetNeedsRedraw();
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
 
@@ skipping 19 matching lines @@
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(1, client_->num_draws());
   EXPECT_TRUE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_TRUE(client_->HasAction("ScheduledActionPrepareTiles"));
   EXPECT_LT(client_->ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
             client_->ActionIndex("ScheduledActionPrepareTiles"));
   EXPECT_FALSE(scheduler_->RedrawPending());
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
-  scheduler_->DidPrepareTiles();  // Corresponds to ScheduledActionPrepareTiles
 }
 
 TEST_F(SchedulerTest, TriggerBeginFrameDeadlineEarly) {
   SchedulerClientNeedsPrepareTilesInDraw* client =
       new SchedulerClientNeedsPrepareTilesInDraw;
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(make_scoped_ptr(client).Pass(), true);
 
   scheduler_->SetNeedsRedraw();
   EXPECT_SCOPED(AdvanceFrame());
@@ skipping 85 matching lines @@
   EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 3);
   EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
 }
 
 void SchedulerTest::MainFrameInHighLatencyMode(
     int64 begin_main_frame_to_commit_estimate_in_ms,
     int64 commit_to_activate_estimate_in_ms,
     bool impl_latency_takes_priority,
     bool should_send_begin_main_frame) {
-  // Set up client with specified estimates (draw duration is set to 1).
-  SchedulerClientWithFixedEstimates* client =
-      new SchedulerClientWithFixedEstimates(
-          base::TimeDelta::FromMilliseconds(1),
-          base::TimeDelta::FromMilliseconds(
-              begin_main_frame_to_commit_estimate_in_ms),
-          base::TimeDelta::FromMilliseconds(commit_to_activate_estimate_in_ms));
+  scheduler_settings_.use_external_begin_frame_source = true;
+  SetUpScheduler(true);

[picksi, 2015/06/19 13:04:28]

I see it is a common pattern, but SetUpScheduler(true) leaves me not knowing
what the 'true' means. Is it worth either making a wrapper function
SetUpSchedulerWithLogging() [you see, I really have no idea what the 'true'
means], or having a const/enum to pass as a self explanatory parameter?

[brianderson, 2015/06/19 17:24:27]

Good idea. I can clean that up in a separate patch.

 
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(make_scoped_ptr(client).Pass(), true);
+  scheduler_->SetDrawDurationEstimate(base::TimeDelta::FromMilliseconds(1));
+  scheduler_->SetBeginMainFrameToCommitDurationEstimate(
+      base::TimeDelta::FromMilliseconds(
+          begin_main_frame_to_commit_estimate_in_ms));
+  scheduler_->SetPrepareTilesToReadyToActivateDurationEstimate(
+      base::TimeDelta::FromMilliseconds(commit_to_activate_estimate_in_ms));
 
   scheduler_->SetImplLatencyTakesPriority(impl_latency_takes_priority);
 
   // Impl thread hits deadline before commit finishes.
   scheduler_->SetNeedsCommit();
   EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
   scheduler_->NotifyBeginMainFrameStarted();
   scheduler_->NotifyReadyToCommit();
   scheduler_->NotifyReadyToActivate();
   EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
-  EXPECT_TRUE(client->HasAction("ScheduledActionSendBeginMainFrame"));
+  EXPECT_TRUE(client_->HasAction("ScheduledActionSendBeginMainFrame"));
 
-  client->Reset();
+  client_->Reset();
   scheduler_->SetNeedsCommit();
   EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(scheduler_->MainThreadIsInHighLatencyMode(),
             should_send_begin_main_frame);
-  EXPECT_EQ(client->HasAction("ScheduledActionSendBeginMainFrame"),
+  EXPECT_EQ(client_->HasAction("ScheduledActionSendBeginMainFrame"),
             should_send_begin_main_frame);
 }
 
 TEST_F(SchedulerTest,
        SkipMainFrameIfHighLatencyAndCanCommitAndActivateBeforeDeadline) {
   // Set up client so that estimates indicate that we can commit and activate
   // before the deadline (~8ms by default).
   EXPECT_SCOPED(MainFrameInHighLatencyMode(1, 1, false, false));
 }
 
@@ skipping 19 matching lines @@
 TEST_F(SchedulerTest,
        Deadlock_NotifyReadyToCommitMakesProgressWhileSwapTrottled) {
   // NPAPI plugins on Windows block the Browser UI thread on the Renderer main
   // thread. This prevents the scheduler from receiving any pending swap acks.
   // This test makes sure that we keep updating the TextureUploader with
   // DidAnticipatedDrawTimeChange's so that it can make forward progress and
   // upload all the textures needed for the commit to complete.
 
   // Since we are simulating a long commit, set up a client with draw duration
   // estimates that prevent skipping main frames to get to low latency mode.
-  SchedulerClientWithFixedEstimates* client =
-      new SchedulerClientWithFixedEstimates(
-          base::TimeDelta::FromMilliseconds(1),
-          base::TimeDelta::FromMilliseconds(32),
-          base::TimeDelta::FromMilliseconds(32));
   scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(make_scoped_ptr(client).Pass(), true);
+  SetUpScheduler(true);
 
-  client->set_log_anticipated_draw_time_change(true);
+  scheduler_->SetDrawDurationEstimate(base::TimeDelta::FromMilliseconds(1));
+  scheduler_->SetBeginMainFrameToCommitDurationEstimate(
+      base::TimeDelta::FromMilliseconds(32));
+  scheduler_->SetPrepareTilesToReadyToActivateDurationEstimate(
+      base::TimeDelta::FromMilliseconds(32));
+
+  client_->set_log_anticipated_draw_time_change(true);
 
   BeginFrameArgs frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src());
   frame_args.interval = base::TimeDelta::FromMilliseconds(1000);
 
   // At this point, we've drawn a frame. Start another commit, but hold off on
   // the NotifyReadyToCommit for now.
   EXPECT_FALSE(scheduler_->CommitPending());
   scheduler_->SetNeedsCommit();
   fake_external_begin_frame_source()->TestOnBeginFrame(frame_args);
   EXPECT_TRUE(scheduler_->CommitPending());
 
   // Draw and swap the frame, but don't ack the swap to simulate the Browser
   // blocking on the renderer.
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
   scheduler_->DidSwapBuffers();
 
   // Spin the event loop a few times and make sure we get more
   // DidAnticipateDrawTimeChange calls every time.
-  int actions_so_far = client->num_actions_();
+  int actions_so_far = client_->num_actions_();
 
   // Does three iterations to make sure that the timer is properly repeating.
   for (int i = 0; i < 3; ++i) {
     EXPECT_EQ((frame_args.interval * 2).InMicroseconds(),
               task_runner().DelayToNextTaskTime().InMicroseconds())
         << scheduler_->AsValue()->ToString();
     task_runner().RunPendingTasks();
-    EXPECT_GT(client->num_actions_(), actions_so_far);
-    EXPECT_STREQ(client->Action(client->num_actions_() - 1),
+    EXPECT_GT(client_->num_actions_(), actions_so_far);
+    EXPECT_STREQ(client_->Action(client_->num_actions_() - 1),
                  "DidAnticipatedDrawTimeChange");
-    actions_so_far = client->num_actions_();
+    actions_so_far = client_->num_actions_();
   }
 
   // Do the same thing after BeginMainFrame starts but still before activation.
   scheduler_->NotifyBeginMainFrameStarted();
   for (int i = 0; i < 3; ++i) {
     EXPECT_EQ((frame_args.interval * 2).InMicroseconds(),
               task_runner().DelayToNextTaskTime().InMicroseconds())
         << scheduler_->AsValue()->ToString();
     task_runner().RunPendingTasks();
-    EXPECT_GT(client->num_actions_(), actions_so_far);
-    EXPECT_STREQ(client->Action(client->num_actions_() - 1),
+    EXPECT_GT(client_->num_actions_(), actions_so_far);
+    EXPECT_STREQ(client_->Action(client_->num_actions_() - 1),
                  "DidAnticipatedDrawTimeChange");
-    actions_so_far = client->num_actions_();
+    actions_so_far = client_->num_actions_();
   }
 }
 
 TEST_F(
     SchedulerTest,
     Deadlock_CommitMakesProgressWhileSwapTrottledAndActiveTreeNeedsFirstDraw) {
   // NPAPI plugins on Windows block the Browser UI thread on the Renderer main
   // thread. This prevents the scheduler from receiving any pending swap acks.
 
   // Since we are simulating a long commit, set up a client with draw duration
   // estimates that prevent skipping main frames to get to low latency mode.
-  SchedulerClientWithFixedEstimates* client =
-      new SchedulerClientWithFixedEstimates(
-          base::TimeDelta::FromMilliseconds(1),
-          base::TimeDelta::FromMilliseconds(32),
-          base::TimeDelta::FromMilliseconds(32));
   scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.main_frame_while_swap_throttled_enabled = true;
-  SetUpScheduler(make_scoped_ptr(client).Pass(), true);
+  SetUpScheduler(true);
+
+  scheduler_->SetDrawDurationEstimate(base::TimeDelta::FromMilliseconds(1));
+  scheduler_->SetBeginMainFrameToCommitDurationEstimate(
+      base::TimeDelta::FromMilliseconds(32));
+  scheduler_->SetPrepareTilesToReadyToActivateDurationEstimate(
+      base::TimeDelta::FromMilliseconds(32));
 
   // Disables automatic swap acks so this test can force swap ack throttling
   // to simulate a blocked Browser ui thread.
   scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // Get a new active tree in main-thread high latency mode and put us
   // in a swap throttled state.
   client_->Reset();
   EXPECT_FALSE(scheduler_->CommitPending());
@@ skipping 49 matching lines @@
        Deadlock_NoBeginMainFrameWhileSwapTrottledAndPipelineFull) {
   // NPAPI plugins on Windows block the Browser UI thread on the Renderer main
   // thread. This prevents the scheduler from receiving any pending swap acks.
 
   // This particular test makes sure we do not send a BeginMainFrame while
   // swap trottled and we have a pending tree and active tree that
   // still needs to be drawn for the first time.
 
   // Since we are simulating a long commit, set up a client with draw duration
   // estimates that prevent skipping main frames to get to low latency mode.
-  SchedulerClientWithFixedEstimates* client =
-      new SchedulerClientWithFixedEstimates(
-          base::TimeDelta::FromMilliseconds(1),
-          base::TimeDelta::FromMilliseconds(32),
-          base::TimeDelta::FromMilliseconds(32));
   scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.main_frame_while_swap_throttled_enabled = true;
   scheduler_settings_.main_frame_before_activation_enabled = true;
-  SetUpScheduler(make_scoped_ptr(client).Pass(), true);
+  SetUpScheduler(true);
+
+  scheduler_->SetDrawDurationEstimate(base::TimeDelta::FromMilliseconds(1));
+  scheduler_->SetBeginMainFrameToCommitDurationEstimate(
+      base::TimeDelta::FromMilliseconds(32));
+  scheduler_->SetPrepareTilesToReadyToActivateDurationEstimate(
+      base::TimeDelta::FromMilliseconds(32));
 
   // Disables automatic swap acks so this test can force swap ack throttling
   // to simulate a blocked Browser ui thread.
   scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // Start a new commit in main-thread high latency mode and hold off on
   // activation.
   client_->Reset();
   EXPECT_FALSE(scheduler_->CommitPending());
@@ skipping 57 matching lines @@
 }
 
 TEST_F(
     SchedulerTest,
     CommitMakesProgressWhenIdleAndHasPendingTreeAndActiveTreeNeedsFirstDraw) {
   // This verifies we don't block commits longer than we need to
   // for performance reasons - not deadlock reasons.
 
   // Since we are simulating a long commit, set up a client with draw duration
   // estimates that prevent skipping main frames to get to low latency mode.
-  SchedulerClientWithFixedEstimates* client =
-      new SchedulerClientWithFixedEstimates(
-          base::TimeDelta::FromMilliseconds(1),
-          base::TimeDelta::FromMilliseconds(32),
-          base::TimeDelta::FromMilliseconds(32));
   scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.main_frame_while_swap_throttled_enabled = true;
   scheduler_settings_.main_frame_before_activation_enabled = true;
-  SetUpScheduler(make_scoped_ptr(client).Pass(), true);
+  SetUpScheduler(true);
+
+  scheduler_->SetDrawDurationEstimate(base::TimeDelta::FromMilliseconds(1));
+  scheduler_->SetBeginMainFrameToCommitDurationEstimate(
+      base::TimeDelta::FromMilliseconds(32));
+  scheduler_->SetPrepareTilesToReadyToActivateDurationEstimate(
+      base::TimeDelta::FromMilliseconds(32));
 
   // Disables automatic swap acks so this test can force swap ack throttling
   // to simulate a blocked Browser ui thread.
   scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // Start a new commit in main-thread high latency mode and hold off on
   // activation.
   client_->Reset();
   EXPECT_FALSE(scheduler_->CommitPending());
@@ skipping 1288 matching lines @@
 
 class SchedulerClientSetNeedsPrepareTilesOnDraw : public FakeSchedulerClient {
  public:
   SchedulerClientSetNeedsPrepareTilesOnDraw() : FakeSchedulerClient() {}
 
  protected:
   DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     scheduler_->SetNeedsPrepareTiles();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
-
-  void ScheduledActionPrepareTiles() override {
-    FakeSchedulerClient::ScheduledActionPrepareTiles();
-    scheduler_->DidPrepareTiles();
-  }
 };
 
 TEST_F(SchedulerTest, SynchronousCompositorPrepareTilesOnDraw) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
   scheduler_settings_.use_external_begin_frame_source = true;
 
   scoped_ptr<FakeSchedulerClient> client =
       make_scoped_ptr(new SchedulerClientSetNeedsPrepareTilesOnDraw);
   SetUpScheduler(client.Pass(), true);
 
@@ skipping 90 matching lines @@
   scheduler_->SetImplLatencyTakesPriority(true);
   scheduler_->SetChildrenNeedBeginFrames(true);
 
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(client_->begin_frame_is_sent_to_children());
   EXPECT_FALSE(client_->begin_frame_args_sent_to_children().on_critical_path);
 }
 
 }  // namespace
 }  // namespace cc