[cc] Remove remaining_frames from BeginFrameAck.

cc/scheduler/begin_frame_source_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/begin_frame_source.h"
 
 #include <stdint.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/test/test_simple_task_runner.h"
@@ skipping 56 matching lines @@
   source_->AddObserver(obs_.get());
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,
                           1000 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100,
                           1100 + kDeadline, kInterval);
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest,
        RemoveObserverThenDidFinishFrameProducesNoFrame) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,
                           1000 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   source_->RemoveObserver(obs_.get());
   source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
 
   // Verify no BeginFrame is sent to |obs_|. There is a pending task in the
   // task_runner_ as a BeginFrame was posted, but it gets aborted since |obs_|
   // is removed.
   task_runner_->RunPendingTasks();
   EXPECT_FALSE(task_runner_->HasPendingTasks());
 }
 
 TEST_F(BackToBackBeginFrameSourceTest,
        DidFinishFrameThenRemoveObserverProducesNoFrame) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,
                           1000 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
   source_->RemoveObserver(obs_.get());
 
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest,
        TogglingObserverThenDidFinishFrameProducesCorrectFrame) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,
                           1000 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->RemoveObserver(obs_.get());
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   // The begin frame is posted at the time when the observer was added,
   // so it ignores changes to "now" afterward.
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1110,
                           1110 + kDeadline, kInterval);
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest,
        DidFinishFrameThenTogglingObserverProducesCorrectFrame) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,
                           1000 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   source_->RemoveObserver(obs_.get());
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   // Ticks at the time at which the observer was added, ignoring the
   // last change to "now".
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1120,
                           1120 + kDeadline, kInterval);
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameNoObserver) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   source_->RemoveObserver(obs_.get());
   source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
   EXPECT_FALSE(task_runner_->RunPendingTasks());
 }
 
-TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameRemainingFrames) {
-  EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
-  source_->AddObserver(obs_.get());
-  EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,
-                          1000 + kDeadline, kInterval);
-  // Runs the pending begin frame.
-  task_runner_->RunPendingTasks();
-  // While running the begin frame, the next frame was cancelled, this
-  // runs the next frame, sees it was cancelled, and goes to sleep.
-  task_runner_->RunPendingTasks();
-  EXPECT_FALSE(task_runner_->HasPendingTasks());
-
-  now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
-
-  source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 1, 1, 3, true));
-  EXPECT_FALSE(task_runner_->HasPendingTasks());
-  source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 1, 1, 2, true));
-  EXPECT_FALSE(task_runner_->HasPendingTasks());
-  source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 1, 1, 1, true));
-  EXPECT_FALSE(task_runner_->HasPendingTasks());
-
-  EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100,
-                          1100 + kDeadline, kInterval);
-  source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
-  EXPECT_EQ(base::TimeDelta(), task_runner_->DelayToNextTaskTime());
-  task_runner_->RunPendingTasks();
-}
-
 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameMultipleCallsIdempotent) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,
                           1000 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
   source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
   source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100,
                           1100 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 2, 2, 0, true));
+                          BeginFrameAck(source_->source_id(), 2, 2, true));
   source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 2, 2, 0, true));
+                          BeginFrameAck(source_->source_id(), 2, 2, true));
   source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 2, 2, 0, true));
+                          BeginFrameAck(source_->source_id(), 2, 2, true));
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 1200,
                           1200 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest, DelayInPostedTaskProducesCorrectFrame) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,
                           1000 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(obs_.get(),
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
   now_src_->Advance(base::TimeDelta::FromMicroseconds(50));
   // Ticks at the time the last frame finished, so ignores the last change to
   // "now".
   EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100,
                           1100 + kDeadline, kInterval);
 
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversSynchronized) {
   StrictMock<MockBeginFrameObserver> obs1, obs2;
 
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false);
   source_->AddObserver(&obs1);
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false);
   source_->AddObserver(&obs2);
 
   EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline,
                           kInterval);
   EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline,
                           kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(&obs1,
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
   source_->DidFinishFrame(&obs2,
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
   EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline,
                           kInterval);
   EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline,
                           kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(&obs1,
-                          BeginFrameAck(source_->source_id(), 2, 2, 0, true));
+                          BeginFrameAck(source_->source_id(), 2, 2, true));
   source_->DidFinishFrame(&obs2,
-                          BeginFrameAck(source_->source_id(), 2, 2, 0, true));
+                          BeginFrameAck(source_->source_id(), 2, 2, true));
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   source_->RemoveObserver(&obs1);
   source_->RemoveObserver(&obs2);
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversInterleaved) {
   StrictMock<MockBeginFrameObserver> obs1, obs2;
 
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false);
   source_->AddObserver(&obs1);
   EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline,
                           kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false);
   source_->AddObserver(&obs2);
   EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline,
                           kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(&obs1,
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
   EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 3, 1200, 1200 + kDeadline,
                           kInterval);
   task_runner_->RunPendingTasks();
 
   source_->DidFinishFrame(&obs1,
-                          BeginFrameAck(source_->source_id(), 3, 3, 0, true));
+                          BeginFrameAck(source_->source_id(), 3, 3, true));
   source_->RemoveObserver(&obs1);
   // Removing all finished observers should disable the time source.
   EXPECT_FALSE(delay_based_time_source_->Active());
   // Finishing the frame for |obs1| posts a begin frame task, which will be
   // aborted since |obs1| is removed. Clear that from the task runner.
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(&obs2,
-                          BeginFrameAck(source_->source_id(), 2, 2, 0, true));
+                          BeginFrameAck(source_->source_id(), 2, 2, true));
   EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 4, 1300, 1300 + kDeadline,
                           kInterval);
   task_runner_->RunPendingTasks();
 
   source_->DidFinishFrame(&obs2,
-                          BeginFrameAck(source_->source_id(), 4, 4, 0, true));
+                          BeginFrameAck(source_->source_id(), 4, 4, true));
   source_->RemoveObserver(&obs2);
 }
 
 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversAtOnce) {
   StrictMock<MockBeginFrameObserver> obs1, obs2;
 
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false);
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false);
   source_->AddObserver(&obs1);
   source_->AddObserver(&obs2);
   EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline,
                           kInterval);
   EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline,
                           kInterval);
   task_runner_->RunPendingTasks();
 
   // |obs1| finishes first.
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(&obs1,
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
 
   // |obs2| finishes also, before getting to the newly posted begin frame.
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(&obs2,
-                          BeginFrameAck(source_->source_id(), 1, 1, 0, true));
+                          BeginFrameAck(source_->source_id(), 1, 1, true));
 
   // Because the begin frame source already ticked when |obs1| finished,
   // we see it as the frame time for both observers.
   EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline,
                           kInterval);
   EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline,
                           kInterval);
   task_runner_->RunPendingTasks();
 
   source_->DidFinishFrame(&obs1,
-                          BeginFrameAck(source_->source_id(), 2, 2, 0, true));
+                          BeginFrameAck(source_->source_id(), 2, 2, true));
   source_->RemoveObserver(&obs1);
   source_->DidFinishFrame(&obs2,
-                          BeginFrameAck(source_->source_id(), 2, 2, 0, true));
+                          BeginFrameAck(source_->source_id(), 2, 2, true));
   source_->RemoveObserver(&obs2);
 }
 
 // DelayBasedBeginFrameSource testing ------------------------------------------
 class DelayBasedBeginFrameSourceTest : public ::testing::Test {
  public:
   std::unique_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   std::unique_ptr<DelayBasedBeginFrameSource> source_;
   std::unique_ptr<MockBeginFrameObserver> obs_;
@@ skipping 250 matching lines @@
   tracker_->OnObserverRemoved(&obs1_);
   EXPECT_ACK_TRACKER_STATE(true, false, 1u);
 
   // After adding it back, the BeginFrame is again not finished or confirmed.
   tracker_->OnObserverAdded(&obs1_);
   EXPECT_ACK_TRACKER_STATE(false, false, 0u);  // up to date to previous frame.
 
   // When the observer finishes and confirms, the BeginFrame is finished
   // and confirmed.
   obs1_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 1, 1, 0, false));
+  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 1, 1, false));
   EXPECT_ACK_TRACKER_STATE(true, false, 1u);
 
   // A new BeginFrame is initially not finished or confirmed.
   current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 2);
   tracker_->OnBeginFrame(current_args_);
   EXPECT_ACK_TRACKER_STATE(false, false, 1u);
 
   // Stray ACK for an old BeginFrame is ignored.
-  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 1, 1, 0, false));
+  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 1, 1, false));
   EXPECT_ACK_TRACKER_STATE(false, false, 1u);
 
   // When the observer finishes but doesn't confirm, the BeginFrame is finished
   // but not confirmed.
   obs1_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 2, 1, 0, false));
+  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 2, 1, false));
   EXPECT_ACK_TRACKER_STATE(true, false, 1u);
 
   // Damage from ACK propagates.
   current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 3);
   tracker_->OnBeginFrame(current_args_);
   EXPECT_ACK_TRACKER_STATE(false, false, 1u);
   obs1_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 3, 3, 0, true));
+  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 3, 3, true));
   EXPECT_ACK_TRACKER_STATE(true, true, 3u);
 
   // Removing an out-of-date observer confirms the latest BeginFrame.
   current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 4);
   tracker_->OnBeginFrame(current_args_);
   EXPECT_ACK_TRACKER_STATE(false, false, 3u);
   obs1_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 4, 3, 0, false));
+  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 4, 3, false));
   EXPECT_ACK_TRACKER_STATE(true, false, 3u);
   tracker_->OnObserverRemoved(&obs1_);
   EXPECT_ACK_TRACKER_STATE(true, false, 4u);
 }
 
 TEST_F(BeginFrameObserverAckTrackerTest, CorrectnessWith2Observers) {
   // Check initial state.
   EXPECT_ACK_TRACKER_STATE(true, false, 1u);
 
   // After adding observers, the BeginFrame is not finished or confirmed.
   tracker_->OnObserverAdded(&obs1_);
   EXPECT_ACK_TRACKER_STATE(false, false, 0u);  // up to date to previous frame.
   tracker_->OnObserverAdded(&obs2_);
   EXPECT_ACK_TRACKER_STATE(false, false, 0u);  // up to date to previous frame.
 
   // Removing one of them changes nothing. Same for adding back.
   tracker_->OnObserverRemoved(&obs1_);
   EXPECT_ACK_TRACKER_STATE(false, false, 0u);
   tracker_->OnObserverAdded(&obs1_);
   EXPECT_ACK_TRACKER_STATE(false, false, 0u);
 
   // When one observer finishes and confirms, nothing changes.
   obs1_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 1, 1, 0, false));
+  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 1, 1, false));
   EXPECT_ACK_TRACKER_STATE(false, false, 0u);
   // When both finish and confirm, the BeginFrame is finished and confirmed.
   obs2_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 1, 1, 0, false));
+  tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 1, 1, false));
   EXPECT_ACK_TRACKER_STATE(true, false, 1u);
 
   // A new BeginFrame is not finished or confirmed.
   current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 2);
   tracker_->OnBeginFrame(current_args_);
   EXPECT_ACK_TRACKER_STATE(false, false, 1u);
 
   // When both observers finish but only one confirms, the BeginFrame is
   // finished but not confirmed.
   obs1_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 2, 2, 0, false));
+  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 2, 2, false));
   EXPECT_ACK_TRACKER_STATE(false, false, 1u);
   obs2_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 2, 1, 0, false));
+  tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 2, 1, false));
   EXPECT_ACK_TRACKER_STATE(true, false, 1u);
 
   // With reversed confirmations in the next ACKs, the latest confirmed frame
   // increases but the latest BeginFrame remains unconfirmed.
   current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 3);
   tracker_->OnBeginFrame(current_args_);
   EXPECT_ACK_TRACKER_STATE(false, false, 1u);
   obs1_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 3, 2, 0, false));
+  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 3, 2, false));
   EXPECT_ACK_TRACKER_STATE(false, false, 1u);
   obs2_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 3, 3, 0, false));
+  tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 3, 3, false));
   EXPECT_ACK_TRACKER_STATE(true, false, 2u);
 
   // Only a single ACK with damage suffices.
   current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 4);
   tracker_->OnBeginFrame(current_args_);
   EXPECT_ACK_TRACKER_STATE(false, false, 2u);
   obs1_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 4, 4, 0, true));
+  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 4, 4, true));
   EXPECT_ACK_TRACKER_STATE(false, true, 3u);
   obs2_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 4, 4, 0, false));
+  tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 4, 4, false));
   EXPECT_ACK_TRACKER_STATE(true, true, 4u);
 
   // Removing the damaging observer makes no difference in this case.
   tracker_->OnObserverRemoved(&obs1_);
   EXPECT_ACK_TRACKER_STATE(true, true, 4u);
 
   // Adding the observer back considers it up to date up to the current
   // BeginFrame, because it is the last used one. Thus, the current BeginFrame
   // is still finished, too.
   tracker_->OnObserverAdded(&obs1_);
   EXPECT_ACK_TRACKER_STATE(true, true, 4u);
 
   // Adding the observer back after the next BeginFrame considers it up to date
   // up to last BeginFrame only.
   tracker_->OnObserverRemoved(&obs1_);
   current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 5);
   tracker_->OnBeginFrame(current_args_);
   tracker_->OnObserverAdded(&obs1_);
   EXPECT_ACK_TRACKER_STATE(false, false, 4u);
   // Both observers need to finish for the BeginFrame to be finished.
   obs1_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 5, 5, 0, false));
+  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 5, 5, false));
   EXPECT_ACK_TRACKER_STATE(false, false, 4u);
   obs2_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 5, 5, 0, false));
+  tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 5, 5, false));
   EXPECT_ACK_TRACKER_STATE(true, false, 5u);
 }
 
 TEST_F(BeginFrameObserverAckTrackerTest, ChangingSourceIdOnBeginFrame) {
   // Check initial state.
   EXPECT_ACK_TRACKER_STATE(true, false, 1u);
 
   // Changing source id without observer updates confirmed BeginFrame.
   current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 1, 10);
   tracker_->OnBeginFrame(current_args_);
   EXPECT_ACK_TRACKER_STATE(true, false, 10u);
 
   // Setup an observer for current BeginFrame.
   tracker_->OnObserverAdded(&obs1_);
   EXPECT_ACK_TRACKER_STATE(false, false, 9u);  // up to date to previous frame.
   obs1_.OnBeginFrame(current_args_);
-  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(1, 10, 10, 0, true));
+  tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(1, 10, 10, true));
   EXPECT_ACK_TRACKER_STATE(true, true, 10u);
 
   // Changing source id with an observer sets confirmed BeginFrame to invalid.
   current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 2, 20);
   tracker_->OnBeginFrame(current_args_);
   EXPECT_ACK_TRACKER_STATE(false, false, BeginFrameArgs::kInvalidFrameNumber);
 }
 
 // ExternalBeginFrameSource testing --------------------------------------------
 class MockExternalBeginFrameSourceClient
@@ skipping 15 matching lines @@
     obs_.reset(new MockBeginFrameObserver);
   }
 
   void TearDown() override {
     client_.reset();
     obs_.reset();
   }
 };
 
 TEST_F(ExternalBeginFrameSourceTest, CallsOnDidFinishFrameWithoutObservers) {
-  EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 2, 0, false)))
+  EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 2, false)))
       .Times(1);
   source_->OnBeginFrame(CreateBeginFrameArgsForTesting(
       BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000)));
 }
 
 TEST_F(ExternalBeginFrameSourceTest,
        CallsOnDidFinishFrameWhenObserverFinishes) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1);
   source_->AddObserver(obs_.get());
 
   BeginFrameArgs args = CreateBeginFrameArgsForTesting(
       BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000));
   EXPECT_BEGIN_FRAME_ARGS_USED(*obs_, args);
   source_->OnBeginFrame(args);
 
-  EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 2, 0, true)))
+  EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 2, true)))
       .Times(1);
-  source_->DidFinishFrame(obs_.get(), BeginFrameAck(0, 2, 2, 0, true));
+  source_->DidFinishFrame(obs_.get(), BeginFrameAck(0, 2, 2, true));
 
   args = CreateBeginFrameArgsForTesting(
       BEGINFRAME_FROM_HERE, 0, 3, base::TimeTicks::FromInternalValue(20000));
   EXPECT_BEGIN_FRAME_ARGS_USED(*obs_, args);
   source_->OnBeginFrame(args);
 
-  EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 3, 2, 0, false)))
+  EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 3, 2, false)))
       .Times(1);
-  source_->DidFinishFrame(obs_.get(), BeginFrameAck(0, 3, 2, 0, false));
+  source_->DidFinishFrame(obs_.get(), BeginFrameAck(0, 3, 2, false));
 }
 
 TEST_F(ExternalBeginFrameSourceTest,
        CallsOnDidFinishFrameWhenObserverDropsBeginFrame) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1);
   source_->AddObserver(obs_.get());
 
   BeginFrameArgs args = CreateBeginFrameArgsForTesting(
       BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000));
   EXPECT_BEGIN_FRAME_ARGS_DROP(*obs_, args);
   source_->OnBeginFrame(args);
-  EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 0, 0, false)))
+  EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 0, false)))
       .Times(1);
-  source_->DidFinishFrame(obs_.get(), BeginFrameAck(0, 2, 0, 0, false));
+  source_->DidFinishFrame(obs_.get(), BeginFrameAck(0, 2, 0, false));
 }
 
 TEST_F(ExternalBeginFrameSourceTest, CallsOnDidFinishFrameWhenObserverRemoved) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1);
   source_->AddObserver(obs_.get());
 
   BeginFrameArgs args = CreateBeginFrameArgsForTesting(
       BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000));
   EXPECT_BEGIN_FRAME_ARGS_USED(*obs_, args);
   source_->OnBeginFrame(args);
 
-  EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 2, 0, false)))
+  EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 2, false)))
       .Times(1);
   EXPECT_CALL((*client_), OnNeedsBeginFrames(false)).Times(1);
   source_->RemoveObserver(obs_.get());
 }
 
 // https://crbug.com/690127: Duplicate BeginFrame caused DCHECK crash.
 TEST_F(ExternalBeginFrameSourceTest, OnBeginFrameChecksBeginFrameContinuity) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1);
   source_->AddObserver(obs_.get());
 
   BeginFrameArgs args = CreateBeginFrameArgsForTesting(
       BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000));
   EXPECT_BEGIN_FRAME_ARGS_USED(*obs_, args);
   source_->OnBeginFrame(args);
 
   // Providing same args again to OnBeginFrame() should not notify observer.
-  EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 0, 0, false)))
+  EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 0, false)))
       .Times(1);
   source_->OnBeginFrame(args);
 
   // Providing same args through a different ExternalBeginFrameSource also does
   // not notify observer.
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1);
   ExternalBeginFrameSource source2(client_.get());
   source2.AddObserver(obs_.get());
   source2.OnBeginFrame(args);
 }
 
 }  // namespace
 }  // namespace cc