[cc] Remove BeginFrameAck from BFS::DidFinishFrame and update tests.

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 <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 54 matching lines @@
 
   void Reset() {
     actions_.clear();
     states_.clear();
     will_begin_impl_frame_causes_redraw_ = false;
     will_begin_impl_frame_requests_one_begin_impl_frame_ = false;
     draw_will_happen_ = true;
     swap_will_happen_if_draw_happens_ = true;
     num_draws_ = 0;
     last_begin_main_frame_args_ = BeginFrameArgs();
+    last_begin_frame_ack_ = BeginFrameAck();
   }
 
   void set_scheduler(TestScheduler* scheduler) { scheduler_ = scheduler; }
 
   bool needs_begin_frames() { return scheduler_->begin_frames_expected(); }
   int num_draws() const { return num_draws_; }
   int num_actions_() const { return static_cast<int>(actions_.size()); }
   const char* Action(int i) const { return actions_[i]; }
   std::string StateForAction(int i) const { return states_[i]->ToString(); }
   base::TimeTicks posted_begin_impl_frame_deadline() const {
@@ skipping 31 matching lines @@
     PushAction("WillBeginImplFrame");
     if (will_begin_impl_frame_requests_one_begin_impl_frame_)
       scheduler_->SetNeedsOneBeginImplFrame();
     if (will_begin_impl_frame_causes_redraw_)
       scheduler_->SetNeedsRedraw();
   }
   void DidFinishImplFrame() override {
     EXPECT_TRUE(inside_begin_impl_frame_);
     inside_begin_impl_frame_ = false;
   }
-  void DidNotProduceFrame(const BeginFrameAck& ack) override {}
+  void DidNotProduceFrame(const BeginFrameAck& ack) override {
+    last_begin_frame_ack_ = ack;
+  }
 
   void ScheduledActionSendBeginMainFrame(const BeginFrameArgs& args) override {
     PushAction("ScheduledActionSendBeginMainFrame");
     last_begin_main_frame_args_ = args;
   }
 
   const BeginFrameArgs& last_begin_main_frame_args() {
     return last_begin_main_frame_args_;
   }
 
+  const BeginFrameAck& last_begin_frame_ack() { return last_begin_frame_ack_; }
+
   DrawResult ScheduledActionDrawIfPossible() override {
     PushAction("ScheduledActionDrawIfPossible");
     num_draws_++;
     DrawResult result =
         draw_will_happen_ ? DRAW_SUCCESS : DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
     bool swap_will_happen =
         draw_will_happen_ && swap_will_happen_if_draw_happens_;
     if (swap_will_happen) {
+      last_begin_frame_ack_ = scheduler_->CurrentBeginFrameAckForActiveTree();
       scheduler_->DidSubmitCompositorFrame();
 
       if (automatic_ack_)
         scheduler_->DidReceiveCompositorFrameAck();
     }
     return result;
   }
   DrawResult ScheduledActionDrawForced() override {
     PushAction("ScheduledActionDrawForced");
+    last_begin_frame_ack_ = scheduler_->CurrentBeginFrameAckForActiveTree();
     return DRAW_SUCCESS;
   }
   void ScheduledActionCommit() override {
     PushAction("ScheduledActionCommit");
     scheduler_->DidCommit();
   }
   void ScheduledActionActivateSyncTree() override {
     PushAction("ScheduledActionActivateSyncTree");
   }
   void ScheduledActionBeginCompositorFrameSinkCreation() override {
@@ skipping 57 matching lines @@
   }
 
   bool inside_begin_impl_frame_;
   bool will_begin_impl_frame_causes_redraw_;
   bool will_begin_impl_frame_requests_one_begin_impl_frame_;
   bool draw_will_happen_;
   bool swap_will_happen_if_draw_happens_;
   bool automatic_ack_;
   int num_draws_;
   BeginFrameArgs last_begin_main_frame_args_;
+  BeginFrameAck last_begin_frame_ack_;
   base::TimeTicks posted_begin_impl_frame_deadline_;
   std::vector<const char*> actions_;
   std::vector<std::unique_ptr<base::trace_event::ConvertableToTraceFormat>>
       states_;
   TestScheduler* scheduler_;
 };
 
 enum BeginFrameSourceType {
   EXTERNAL_BFS,
   UNTHROTTLED_BFS,
@@ skipping 141 matching lines @@
       if (!scheduler_settings_.using_synchronous_renderer_compositor) {
         // Run the posted deadline task.
         EXPECT_TRUE(client_->IsInsideBeginImplFrame());
         task_runner_->RunTasksWhile(client_->InsideBeginImplFrame(true));
       }
 
       EXPECT_FALSE(client_->IsInsideBeginImplFrame());
     }
 
     EXPECT_FALSE(scheduler_->begin_frames_expected());
+
+    if (scheduler_->begin_frame_source() ==
+        fake_external_begin_frame_source_.get()) {
+      // Expect the last BeginFrameAck to be for last BeginFrame, which didn't
+      // cause damage.
+      uint64_t last_begin_frame_number =
+          fake_external_begin_frame_source_->next_begin_frame_number() - 1;
+      bool has_damage = false;
+      EXPECT_EQ(BeginFrameAck(fake_external_begin_frame_source_->source_id(),
+                              last_begin_frame_number, last_begin_frame_number,
+                              has_damage),
+                client_->last_begin_frame_ack());
+    }
+
     client_->Reset();
   }
 
   // As this function contains EXPECT macros, to allow debugging it should be
   // called inside EXPECT_SCOPED like so;
   //   EXPECT_SCOPED(client.AdvanceFrame());
   void AdvanceFrame() {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"),
                  "FakeSchedulerClient::AdvanceFrame");
 
@@ skipping 2531 matching lines @@
 
   // Scheduler shuts down the source now that no begin frame is requested.
   EXPECT_ACTION("RemoveObserver(this)", client_, 0, 2);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
 }
 
 TEST_F(SchedulerTest, SynchronousCompositorCommitAndVerifyBeginFrameAcks) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
   SetUpScheduler(EXTERNAL_BFS);
 
-  // Expect the last ack to be for last BeginFrame, which didn't cause damage.
-  uint64_t last_begin_frame_number =
+  // The last BeginFrame was confirmed.
+  uint64_t latest_confirmed_sequence_number =
       fake_external_begin_frame_source_->next_begin_frame_number() - 1;
-  uint64_t latest_confirmed_sequence_number = last_begin_frame_number;
-  bool has_damage = false;
-  EXPECT_EQ(
-      BeginFrameAck(fake_external_begin_frame_source_->source_id(),
-                    last_begin_frame_number, latest_confirmed_sequence_number,
-                    has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
 
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
   // Next vsync.
   BeginFrameArgs args = SendNextBeginFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
+
+  bool has_damage = false;
+  EXPECT_EQ(BeginFrameAck(args.source_id, args.sequence_number,
+                          latest_confirmed_sequence_number, has_damage),
+            client_->last_begin_frame_ack());
   client_->Reset();
 
-  has_damage = false;
-  EXPECT_EQ(
-      BeginFrameAck(args.source_id, args.sequence_number,
-                    latest_confirmed_sequence_number, has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
-
   scheduler_->NotifyBeginMainFrameStarted(base::TimeTicks());
   EXPECT_NO_ACTION(client_);
 
   // Next vsync.
   args = SendNextBeginFrame();
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
-  client_->Reset();
 
   has_damage = false;
-  EXPECT_EQ(
-      BeginFrameAck(args.source_id, args.sequence_number,
-                    latest_confirmed_sequence_number, has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
+  EXPECT_EQ(BeginFrameAck(args.source_id, args.sequence_number,
+                          latest_confirmed_sequence_number, has_damage),
+            client_->last_begin_frame_ack());
+  client_->Reset();
 
   scheduler_->NotifyReadyToCommit();
   EXPECT_ACTION("ScheduledActionCommit", client_, 0, 1);
   client_->Reset();
 
   scheduler_->NotifyReadyToActivate();
   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client_);
   client_->Reset();
 
   // Next vsync.
   args = SendNextBeginFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
   EXPECT_ACTION("ScheduledActionInvalidateCompositorFrameSink", client_, 1, 3);
   EXPECT_ACTION("ScheduledActionBeginMainFrameNotExpectedUntil", client_, 2, 3);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
-  client_->Reset();
 
   // Not confirmed yet and no damage, since not drawn yet.
   // TODO(eseckler): In the future, |has_damage = false| will prevent us from
   // filtering this ack (in CompositorExternalBeginFrameSource) and instead
   // forwarding the one attached to the later submitted CompositorFrame.
   has_damage = false;
-  EXPECT_EQ(
-      BeginFrameAck(args.source_id, args.sequence_number,
-                    latest_confirmed_sequence_number, has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
+  EXPECT_EQ(BeginFrameAck(args.source_id, args.sequence_number,
+                          latest_confirmed_sequence_number, has_damage),
+            client_->last_begin_frame_ack());
+  client_->Reset();
 
   // Android onDraw.
   scheduler_->SetNeedsRedraw();
   bool resourceless_software_draw = false;
   scheduler_->OnDrawForCompositorFrameSink(resourceless_software_draw);
   EXPECT_SINGLE_ACTION("ScheduledActionDrawIfPossible", client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   client_->Reset();
 
   // Idle on next vsync.
   args = SendNextBeginFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 4);
   EXPECT_ACTION("ScheduledActionBeginMainFrameNotExpectedUntil", client_, 1, 4);
   EXPECT_ACTION("RemoveObserver(this)", client_, 2, 4);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 3, 4);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
-  client_->Reset();
 
   latest_confirmed_sequence_number = args.sequence_number;
   has_damage = false;
-  EXPECT_EQ(
-      BeginFrameAck(args.source_id, args.sequence_number,
-                    latest_confirmed_sequence_number, has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
+  EXPECT_EQ(BeginFrameAck(args.source_id, args.sequence_number,
+                          latest_confirmed_sequence_number, has_damage),
+            client_->last_begin_frame_ack());
+  client_->Reset();
 }
 
 TEST_F(SchedulerTest, SynchronousCompositorDoubleCommitWithoutDraw) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
   SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("AddObserver(this)", client_);
   client_->Reset();
 
@@ skipping 413 matching lines @@
 TEST_F(SchedulerTest, BeginMainFrameOnCriticalPath_AHS) {
   EXPECT_FALSE(BeginMainFrameOnCriticalPath(
       SMOOTHNESS_TAKES_PRIORITY,
       ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER, kSlowDuration));
 }
 
 TEST_F(SchedulerTest, BeginFrameAckForFinishedImplFrame) {
   // Sets up scheduler and sends two BeginFrames, both finished.
   SetUpScheduler(EXTERNAL_BFS);
 
-  // Expect the last ack to be for last BeginFrame, which didn't cause damage.
-  uint64_t last_begin_frame_number =
+  // The last BeginFrame was confirmed.
+  uint64_t latest_confirmed_sequence_number =
       fake_external_begin_frame_source_->next_begin_frame_number() - 1;
-  uint64_t latest_confirmed_sequence_number = last_begin_frame_number;
-  bool has_damage = false;
-  EXPECT_EQ(
-      BeginFrameAck(fake_external_begin_frame_source_->source_id(),
-                    last_begin_frame_number, latest_confirmed_sequence_number,
-                    has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
 
   // Run a successful redraw and verify that a new ack is sent.
   scheduler_->SetNeedsRedraw();
   client_->Reset();
 
   BeginFrameArgs args = SendNextBeginFrame();
   EXPECT_LT(latest_confirmed_sequence_number, args.sequence_number);
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionBeginMainFrameNotExpectedUntil", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 1);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
-  client_->Reset();
 
   // Successful draw caused damage.
   latest_confirmed_sequence_number = args.sequence_number;
-  has_damage = true;
-  EXPECT_EQ(
-      BeginFrameAck(args.source_id, args.sequence_number,
-                    latest_confirmed_sequence_number, has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
+  bool has_damage = true;
+  EXPECT_EQ(BeginFrameAck(args.source_id, args.sequence_number,
+                          latest_confirmed_sequence_number, has_damage),
+            client_->last_begin_frame_ack());
+  client_->Reset();

[sunnyps, 2017/05/24 02:38:25]

nit: it's fine to omit the client_->Reset at the end

[Eric Seckler, 2017/05/24 09:00:40]

I moved this from above these checks. Should it not still happen before the
SetNeedsRedraw below, so that we checked that ScheduledActionDrawIfPossible
happened where it should?

Leaving as-is for now.

Or were you referring to Reset() calls at the end of test bodies? I'll leave
them there as well, since that seems to be the common idiom in surrounding code.

 
   // Request another redraw, but fail it. Verify that a new ack is sent, but
   // that its |latest_confirmed_sequence_number| didn't change.
   scheduler_->SetNeedsRedraw();
   client_->Reset();
 
   args = SendNextBeginFrame();
   EXPECT_LT(latest_confirmed_sequence_number, args.sequence_number);
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionBeginMainFrameNotExpectedUntil", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   client_->Reset();
 
   client_->SetDrawWillHappen(false);
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 2);
   // Failed draw triggers SendBeginMainFrame.
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
-  client_->Reset();
 
   // Failed draw: no damage and unconfirmed frame.
   has_damage = false;
-  EXPECT_EQ(
-      BeginFrameAck(args.source_id, args.sequence_number,
-                    latest_confirmed_sequence_number, has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
+  EXPECT_EQ(BeginFrameAck(args.source_id, args.sequence_number,
+                          latest_confirmed_sequence_number, has_damage),
+            client_->last_begin_frame_ack());
+  client_->Reset();
 }
 
 TEST_F(SchedulerTest, BeginFrameAckForSkippedImplFrame) {
   SetUpScheduler(EXTERNAL_BFS);
 
   // To get into a high latency state, this test disables automatic swap acks.
   client_->SetAutomaticSubmitCompositorFrameAck(false);
   fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
   // Run a successful redraw that submits a compositor frame but doesn't receive
   // a swap ack. Verify that a BeginFrameAck is sent for it.
   scheduler_->SetNeedsRedraw();
   client_->Reset();
 
   BeginFrameArgs args = SendNextBeginFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionBeginMainFrameNotExpectedUntil", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 1);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
-  client_->Reset();
 
   // Successful draw caused damage.
   uint64_t latest_confirmed_sequence_number = args.sequence_number;
   bool has_damage = true;
-  EXPECT_EQ(
-      BeginFrameAck(args.source_id, args.sequence_number,
-                    latest_confirmed_sequence_number, has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
+  EXPECT_EQ(BeginFrameAck(args.source_id, args.sequence_number,
+                          latest_confirmed_sequence_number, has_damage),
+            client_->last_begin_frame_ack());
+  client_->Reset();
 
   // Request another redraw that will be skipped because the swap ack is still
   // missing. Verify that a new BeginFrameAck is sent.
   scheduler_->SetNeedsRedraw();
   client_->Reset();
 
   args = SendNextBeginFrame();
   EXPECT_LT(latest_confirmed_sequence_number, args.sequence_number);
   EXPECT_NO_ACTION(client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
-  client_->Reset();
 
   // Skipped draw: no damage and unconfirmed frame.
   has_damage = false;
-  EXPECT_EQ(
-      BeginFrameAck(args.source_id, args.sequence_number,
-                    latest_confirmed_sequence_number, has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
+  EXPECT_EQ(BeginFrameAck(args.source_id, args.sequence_number,
+                          latest_confirmed_sequence_number, has_damage),
+            client_->last_begin_frame_ack());
+  client_->Reset();
 }
 
 TEST_F(SchedulerTest, BeginFrameAckForBeginFrameBeforeLastDeadline) {
   SetUpScheduler(EXTERNAL_BFS);
 
   // Request tile preparation to schedule a proactive BeginFrame.
   scheduler_->SetNeedsPrepareTiles();
   client_->Reset();
 
   SendNextBeginFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionBeginMainFrameNotExpectedUntil", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   // Until tiles were prepared, further proactive BeginFrames are expected.
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   client_->Reset();
 
   // Send the next BeginFrame before the previous one's deadline was executed.
   // This should trigger the previous BeginFrame's deadline synchronously,
   // during which tiles will be prepared. As a result of that, no further
   // BeginFrames will be needed, and the new BeginFrame should be dropped.
   BeginFrameArgs args = SendNextBeginFrame();
   EXPECT_ACTION("ScheduledActionPrepareTiles", client_, 0, 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_FALSE(scheduler_->begin_frames_expected());
-  client_->Reset();
 
   // Latest ack should be for the dropped BeginFrame. Since we don't have
   // further updates, its |latest_confirmed_sequence_number| should be for the
   // dropped BeginFrame, too.
   uint64_t latest_confirmed_sequence_number = args.sequence_number;
   bool has_damage = false;
-  EXPECT_EQ(
-      BeginFrameAck(args.source_id, args.sequence_number,
-                    latest_confirmed_sequence_number, has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
+  EXPECT_EQ(BeginFrameAck(args.source_id, args.sequence_number,
+                          latest_confirmed_sequence_number, has_damage),
+            client_->last_begin_frame_ack());
+  client_->Reset();
 }
 
 TEST_F(SchedulerTest, BeginFrameAckForDroppedBeginFrame) {
   SetUpScheduler(EXTERNAL_BFS);
 
   // Last confirmed frame was last BeginFrame.
   uint64_t latest_confirmed_sequence_number =
       fake_external_begin_frame_source_->next_begin_frame_number() - 1;
 
   // Request a single BeginFrame.
@@ skipping 10 matching lines @@
   // still observing the source.
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   EXPECT_FALSE(scheduler_->BeginFrameNeeded());
   client_->Reset();
 
   // Send the next BeginFrame before the previous one's deadline was executed.
   // The BeginFrame should be dropped immediately, since the state machine is
   // not expecting any BeginFrames.
   BeginFrameArgs second_args = SendNextBeginFrame();
   EXPECT_NO_ACTION(client_);
-  client_->Reset();
 
   // Latest ack should be for the dropped (and unconfirmed) BeginFrame.
   bool has_damage = false;
-  EXPECT_EQ(
-      BeginFrameAck(second_args.source_id, second_args.sequence_number,
-                    latest_confirmed_sequence_number, has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
+  EXPECT_EQ(BeginFrameAck(second_args.source_id, second_args.sequence_number,
+                          latest_confirmed_sequence_number, has_damage),
+            client_->last_begin_frame_ack());
+  client_->Reset();
 
   task_runner().RunPendingTasks();  // Run deadline of prior BeginFrame.
   EXPECT_ACTION("RemoveObserver(this)", client_, 0, 2);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
-  client_->Reset();
 
   // We'd expect an out-of-order ack for the prior BeginFrame, confirming it.
   latest_confirmed_sequence_number = first_args.sequence_number;
   has_damage = false;
-  EXPECT_EQ(
-      BeginFrameAck(first_args.source_id, first_args.sequence_number,
-                    latest_confirmed_sequence_number, has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
+  EXPECT_EQ(BeginFrameAck(first_args.source_id, first_args.sequence_number,
+                          latest_confirmed_sequence_number, has_damage),
+            client_->last_begin_frame_ack());
+  client_->Reset();
 }
 
 TEST_F(SchedulerTest, BeginFrameAckForLateMissedBeginFrame) {
   SetUpScheduler(EXTERNAL_BFS);
 
   // Last confirmed frame was last BeginFrame.
   uint64_t latest_confirmed_sequence_number =
       fake_external_begin_frame_source_->next_begin_frame_number() - 1;
 
   scheduler_->SetNeedsRedraw();
   client_->Reset();
 
   // Send a missed BeginFrame with a passed deadline.
   now_src_->Advance(BeginFrameArgs::DefaultInterval());
   BeginFrameArgs args = fake_external_begin_frame_source_->CreateBeginFrameArgs(
       BEGINFRAME_FROM_HERE, now_src());
   args.type = BeginFrameArgs::MISSED;
   now_src_->Advance(BeginFrameArgs::DefaultInterval());
   EXPECT_GT(now_src_->NowTicks(), args.deadline);
   fake_external_begin_frame_source_->TestOnBeginFrame(args);
 
   EXPECT_NO_ACTION(client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
-  client_->Reset();
 
   // Latest ack should be for the missed BeginFrame that was too late: no damage
   // and unconfirmed frame.
   bool has_damage = false;
-  EXPECT_EQ(
-      BeginFrameAck(args.source_id, args.sequence_number,
-                    latest_confirmed_sequence_number, has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
+  EXPECT_EQ(BeginFrameAck(args.source_id, args.sequence_number,
+                          latest_confirmed_sequence_number, has_damage),
+            client_->last_begin_frame_ack());
+  client_->Reset();
 }
 
 TEST_F(SchedulerTest, BeginFrameAckForFinishedBeginFrameWithNewSourceId) {
   SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsRedraw();
   client_->Reset();
 
   // Send a BeginFrame with a different source_id.
   now_src_->Advance(BeginFrameArgs::DefaultInterval());
   uint32_t source_id = fake_external_begin_frame_source_->source_id() + 1;
   BeginFrameArgs args = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE,
                                                        source_id, 1, now_src());
   fake_external_begin_frame_source_->TestOnBeginFrame(args);
 
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionBeginMainFrameNotExpectedUntil", client_, 1, 2);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionDrawIfPossible", client_, 0, 1);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_TRUE(scheduler_->begin_frames_expected());
-  client_->Reset();
 
   // Successful draw caused damage.
   uint64_t latest_confirmed_sequence_number = args.sequence_number;
   bool has_damage = true;
-  EXPECT_EQ(
-      BeginFrameAck(args.source_id, args.sequence_number,
-                    latest_confirmed_sequence_number, has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
+  EXPECT_EQ(BeginFrameAck(args.source_id, args.sequence_number,
+                          latest_confirmed_sequence_number, has_damage),
+            client_->last_begin_frame_ack());
+  client_->Reset();
 }
 
 TEST_F(SchedulerTest,
        BeginFrameAckForLateMissedBeginFrameWithDifferentSourceId) {
   SetUpScheduler(EXTERNAL_BFS);
 
   scheduler_->SetNeedsRedraw();
   client_->Reset();
 
   // Send a missed BeginFrame with a passed deadline and different source_id.
   now_src_->Advance(BeginFrameArgs::DefaultInterval());
   uint32_t source_id = fake_external_begin_frame_source_->source_id() + 1;
   BeginFrameArgs args = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE,
                                                        source_id, 1, now_src());
   args.type = BeginFrameArgs::MISSED;
   now_src_->Advance(BeginFrameArgs::DefaultInterval());
   EXPECT_GT(now_src_->NowTicks(), args.deadline);
   fake_external_begin_frame_source_->TestOnBeginFrame(args);
 
   EXPECT_NO_ACTION(client_);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
-  client_->Reset();
 
   // Latest ack should be for the missed BeginFrame that was too late: no damage
   // and unconfirmed frame. Because the source_id changed, the
   // |latest_confirmed_sequence_number| should be set to invalid.
   uint64_t latest_confirmed_sequence_number =
       BeginFrameArgs::kInvalidFrameNumber;
   bool has_damage = false;
-  EXPECT_EQ(
-      BeginFrameAck(args.source_id, args.sequence_number,
-                    latest_confirmed_sequence_number, has_damage),
-      fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
+  EXPECT_EQ(BeginFrameAck(args.source_id, args.sequence_number,
+                          latest_confirmed_sequence_number, has_damage),
+            client_->last_begin_frame_ack());
+  client_->Reset();
 }
 
 }  // namespace
 }  // namespace cc