cc: Heuristic for Renderer latency recovery

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"
@@ skipping 132 matching lines @@
     PushAction("ScheduledActionPrepareTiles");
   }
   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(); }
+
+  // Use really long estimations by default so we don't inadvertently
+  // test latency recovery logic unless a test explicitly wants to.
+  base::TimeDelta DrawDurationEstimate() override {
+    return base::TimeDelta::FromHours(1);
+  }
   base::TimeDelta BeginMainFrameToCommitDurationEstimate() override {
-    return base::TimeDelta();
+    return base::TimeDelta::FromHours(1);
   }
   base::TimeDelta CommitToActivateDurationEstimate() override {
-    return base::TimeDelta();
+    return base::TimeDelta::FromHours(1);
   }
 
   void SendBeginFramesToChildren(const BeginFrameArgs& args) override {
     begin_frame_args_sent_to_children_ = args;
   }
 
   void SendBeginMainFrameNotExpectedSoon() override {
     PushAction("SendBeginMainFrameNotExpectedSoon");
   }
 
@@ skipping 27 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 {
+class SchedulerClientWithCustomEstimates : public FakeSchedulerClient {
  public:
-  SchedulerClientWithFixedEstimates(
+  SchedulerClientWithCustomEstimates(
       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:
+ public:
   base::TimeDelta draw_duration_;
   base::TimeDelta begin_main_frame_to_commit_duration_;
   base::TimeDelta commit_to_activate_duration_;
 };
 
 class FakeExternalBeginFrameSource : public BeginFrameSourceMixIn {
  public:
   explicit FakeExternalBeginFrameSource(FakeSchedulerClient* client)
       : client_(client) {}
   ~FakeExternalBeginFrameSource() override {}
@@ skipping 175 matching lines @@
 
   FakeExternalBeginFrameSource* fake_external_begin_frame_source() const {
     return fake_external_begin_frame_source_;
   }
 
   void 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);
+  void SwapIsHighLatency(int64 draw_estimate_in_ms,
+                         int64 begin_main_frame_to_commit_estimate_in_ms,
+                         int64 commit_to_activate_estimate_in_ms,
+                         bool has_impl_side_updates,
+                         bool swap_ack_before_deadline,
+                         bool should_draw_and_swap_in_high_latency);
   void BeginFramesNotFromClient(bool use_external_begin_frame_source,
                                 bool throttle_frame_production);
   void BeginFramesNotFromClient_SwapThrottled(
       bool use_external_begin_frame_source,
       bool throttle_frame_production);
   void DidLoseOutputSurfaceAfterBeginFrameStartedWithHighLatency(
       bool impl_side_painting);
   void DidLoseOutputSurfaceAfterReadyToCommit(bool impl_side_painting);
 
   scoped_refptr<TestNowSource> now_src_;
@@ skipping 46 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(
+  SchedulerClientWithCustomEstimates* client =
+      new SchedulerClientWithCustomEstimates(
           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);
 
   EXPECT_FALSE(client_->needs_begin_frames());
   scheduler_->SetChildrenNeedBeginFrames(true);
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client_);
   EXPECT_TRUE(client_->needs_begin_frames());
@@ skipping 810 matching lines @@
   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(
+  SchedulerClientWithCustomEstimates* client =
+      new SchedulerClientWithCustomEstimates(
           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(make_scoped_ptr(client).Pass(), true);
 
   scheduler_->SetImplLatencyTakesPriority(impl_latency_takes_priority);
 
@@ skipping 17 matching lines @@
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_EQ(scheduler_->MainThreadIsInHighLatencyMode(),
             should_send_begin_main_frame);
   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).
+  // before the deadline (~11ms by default).
   EXPECT_SCOPED(MainFrameInHighLatencyMode(1, 1, false, false));
 }
 
 TEST_F(SchedulerTest, NotSkipMainFrameIfHighLatencyAndCanCommitTooLong) {
   // Set up client so that estimates indicate that the commit cannot finish
-  // before the deadline (~8ms by default).
+  // before the deadline (~11ms by default).
   EXPECT_SCOPED(MainFrameInHighLatencyMode(10, 1, false, true));
 }
 
 TEST_F(SchedulerTest, NotSkipMainFrameIfHighLatencyAndCanActivateTooLong) {
   // Set up client so that estimates indicate that the activate cannot finish
-  // before the deadline (~8ms by default).
+  // before the deadline (~11ms by default).
   EXPECT_SCOPED(MainFrameInHighLatencyMode(1, 10, false, true));
 }
 
 TEST_F(SchedulerTest, NotSkipMainFrameInPreferImplLatencyMode) {
   // Set up client so that estimates indicate that we can commit and activate
-  // before the deadline (~8ms by default), but also enable impl latency takes
+  // before the deadline (~11ms by default), but also enable impl latency takes
   // priority mode.
   EXPECT_SCOPED(MainFrameInHighLatencyMode(1, 1, true, true));
 }
 
+void SchedulerTest::SwapIsHighLatency(
+    int64 draw_estimate_in_ms,
+    int64 begin_main_frame_to_commit_estimate_in_ms,
+    int64 commit_to_activate_estimate_in_ms,
+    bool has_impl_side_updates,
+    bool swap_ack_before_deadline,
+    bool should_draw_and_swap_in_high_latency) {
+  // Set up client with specified estimates.
+  SchedulerClientWithCustomEstimates* client =
+      new SchedulerClientWithCustomEstimates(
+          base::TimeDelta::FromMilliseconds(draw_estimate_in_ms),
+          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(make_scoped_ptr(client).Pass(), true);
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+
+  // To get into a high latency state, this test disables automatic swap acks.
+  scheduler_->SetMaxSwapsPending(1);
+  client_->SetAutomaticSwapAck(false);
+
+  // Draw and swap for first BeginFrame
+  client->Reset();
+  scheduler_->SetNeedsCommit();
+  if (has_impl_side_updates)
+    scheduler_->SetNeedsRedraw();
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  EXPECT_SCOPED(AdvanceFrame());
+  scheduler_->NotifyBeginMainFrameStarted();
+  scheduler_->NotifyReadyToCommit();
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  task_runner().RunPendingTasks();  // Run posted deadline.
+  EXPECT_TRUE(client->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+
+  // Not calling scheduler_->DidSwapBuffersComplete() until after next frame
+  // puts impl thread in high latency mode.
+  client->Reset();
+  scheduler_->SetNeedsCommit();
+  if (has_impl_side_updates)
+    scheduler_->SetNeedsRedraw();
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  EXPECT_SCOPED(AdvanceFrame());
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->SwapsAreLikelyHighLatency());
+
+  if (should_draw_and_swap_in_high_latency) {
+    DCHECK(swap_ack_before_deadline);
+    scheduler_->DidSwapBuffersComplete();
+    scheduler_->NotifyBeginMainFrameStarted();
+    scheduler_->NotifyReadyToCommit();
+    task_runner().RunPendingTasks();  // Run posted deadline.
+  } else if (swap_ack_before_deadline) {
+    scheduler_->DidSwapBuffersComplete();
+    task_runner().RunPendingTasks();  // Run posted deadline.
+  } else {
+    task_runner().RunPendingTasks();  // Run posted deadline.
+    scheduler_->DidSwapBuffersComplete();
+  }
+
+  // Verify that we recovered immediately if we were supposed to.
+  EXPECT_EQ(should_draw_and_swap_in_high_latency,
+            client->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+  if (should_draw_and_swap_in_high_latency)
+    scheduler_->DidSwapBuffersComplete();
+
+  // Verify that we:
+  // 1) Don't skip two frames in a row.
+  // 2) Continue normal operation if we didn't skip a frame.
+  // 3) Make forward progress even when we aren't expecting another swap ack.
+  client->Reset();
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_EQ(scheduler_->SwapsAreLikelyHighLatency(),
+            should_draw_and_swap_in_high_latency);
+  scheduler_->SetNeedsCommit();
+  if (has_impl_side_updates)
+    scheduler_->SetNeedsRedraw();
+  EXPECT_SCOPED(AdvanceFrame());
+  scheduler_->NotifyBeginMainFrameStarted();
+  scheduler_->NotifyReadyToCommit();
+  task_runner().RunPendingTasks();  // Run posted deadline.
+  EXPECT_TRUE(client->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+}
+
+TEST_F(SchedulerTest,
+       SkipSwapIfHighLatencyAndCanDrawBeforeDeadline_SwapAckThenDeadline) {
+  // Set up client so that estimates indicate that we can commit and activate
+  // before the deadline (~11ms by default).
+  EXPECT_SCOPED(SwapIsHighLatency(1, 1, 1, true, true, false));
+}
+
+TEST_F(SchedulerTest,
+       SkipSwapIfHighLatencyAndCanDrawBeforeDeadline_DeadlineThenSwapAck) {
+  // Set up client so that estimates indicate that we can commit and activate
+  // before the deadline (~11ms by default).
+  EXPECT_SCOPED(SwapIsHighLatency(1, 1, 1, true, false, false));
+}
+
+TEST_F(SchedulerTest, NotSkipSwapIfHighLatencyAndCanDrawTooLong) {
+  // Set up client so that estimates indicate that the commit cannot finish
+  // before the deadline (~11ms by default).
+  EXPECT_SCOPED(SwapIsHighLatency(20, 1, 1, true, true, true));
+}
+
+TEST_F(SchedulerTest, NotSkipSwapIfHighLatencyAndCanActivateTooLong) {
+  // Set up client so that estimates indicate that the activate cannot finish
+  // before the deadline (~11ms by default).
+  EXPECT_SCOPED(SwapIsHighLatency(1, 8, 8, false, true, true));
+}
+
+TEST_F(SchedulerTest, MainAndSwapInHighLatencyMode) {
+  // Set up client with custom estimates.
+  // This test starts off with expensive estimates to prevent latency recovery
+  // initially, the lowers the estimates to enable it once both the main
+  // and impl threads are in a high latency mode.
+  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
+  auto slow_duration = base::TimeDelta::FromMilliseconds(10);
+  SchedulerClientWithCustomEstimates* client =
+      new SchedulerClientWithCustomEstimates(slow_duration, slow_duration,
+                                             slow_duration);
+
+  scheduler_settings_.use_external_begin_frame_source = true;
+  SetUpScheduler(make_scoped_ptr(client).Pass(), true);
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+
+  // To get into a high latency state, this test disables automatic swap acks.
+  scheduler_->SetMaxSwapsPending(1);
+  client_->SetAutomaticSwapAck(false);
+
+  // Impl thread hits deadline before commit finishes to make
+  // MainThreadIsInHighLatencyMode true
+  client->Reset();
+  scheduler_->SetNeedsCommit();
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  EXPECT_SCOPED(AdvanceFrame());
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  task_runner().RunPendingTasks();  // Run posted deadline.
+  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  scheduler_->NotifyBeginMainFrameStarted();
+  scheduler_->NotifyReadyToCommit();
+  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  EXPECT_TRUE(client->HasAction("WillBeginImplFrame"));
+  EXPECT_TRUE(client->HasAction("ScheduledActionSendBeginMainFrame"));
+
+  // Draw and swap for first commit, start second commit.
+  client->Reset();
+  scheduler_->SetNeedsCommit();
+  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  EXPECT_SCOPED(AdvanceFrame());
+  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  task_runner().RunPendingTasks();  // Run posted deadline.
+  scheduler_->NotifyBeginMainFrameStarted();
+  scheduler_->NotifyReadyToCommit();
+  EXPECT_TRUE(client->HasAction("WillBeginImplFrame"));
+  EXPECT_TRUE(client->HasAction("ScheduledActionSendBeginMainFrame"));
+  EXPECT_TRUE(client->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+
+  // Don't call scheduler_->DidSwapBuffersComplete() until after next frame
+  // to make SwapsAreLikelyHighLatency true.
+  client->Reset();
+  scheduler_->SetNeedsCommit();
+  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  EXPECT_SCOPED(AdvanceFrame());
+  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->SwapsAreLikelyHighLatency());
+  task_runner().RunPendingTasks();  // Run posted deadline.
+  scheduler_->DidSwapBuffersComplete();
+  EXPECT_TRUE(scheduler_->SwapsAreLikelyHighLatency());
+  EXPECT_TRUE(client->HasAction("WillBeginImplFrame"));
+  // Note: BeginMainFrame and BeginImplFrame are skipped here because
+  // of backpressure, not because of latency recovery.
+  EXPECT_FALSE(client->HasAction("ScheduledActionSendBeginMainFrame"));
+  EXPECT_FALSE(client->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+
+  // Lower estimates so that the scheduler will attempt latency recovery.
+  client->begin_main_frame_to_commit_duration_ = fast_duration;
+  client->commit_to_activate_duration_ = fast_duration;
+  client->draw_duration_ = fast_duration;
+
+  // Now that both threads are in a high latency mode, make sure we
+  // skip the BeginMainFrame, then the BeginImplFrame, but not both
+  // at the same time.
+
+  // Verify we skip BeginMainFrame first.
+  client->Reset();
+  EXPECT_TRUE(scheduler_->NeedsCommit());  // Previous commit still outstanding.
+  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->SwapsAreLikelyHighLatency());
+  SendNextBeginFrame();
+  task_runner().RunPendingTasks();  // Run posted deadline.
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->SwapsAreLikelyHighLatency());
+  EXPECT_TRUE(client->HasAction("WillBeginImplFrame"));
+  EXPECT_FALSE(client->HasAction("ScheduledActionSendBeginMainFrame"));
+  EXPECT_TRUE(client->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+
+  // Verify we skip the DrawAndSwap second.
+  client->Reset();
+  EXPECT_TRUE(scheduler_->NeedsCommit());  // Previous commit still outstanding.
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->SwapsAreLikelyHighLatency());
+  SendNextBeginFrame();
+  task_runner().RunPendingTasks();  // Run posted deadline.
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->SwapsAreLikelyHighLatency());
+  scheduler_->DidSwapBuffersComplete();
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  EXPECT_TRUE(client->HasAction("WillBeginImplFrame"));
+  EXPECT_FALSE(client->HasAction("ScheduledActionSendBeginMainFrame"));
+  EXPECT_FALSE(client->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+
+  // Then verify we operate in a low latency mode.
+  client->Reset();
+  EXPECT_TRUE(scheduler_->NeedsCommit());  // Previous commit still outstanding.
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  SendNextBeginFrame();
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  scheduler_->NotifyBeginMainFrameStarted();
+  scheduler_->NotifyReadyToCommit();
+  task_runner().RunPendingTasks();  // Run posted deadline.
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  scheduler_->DidSwapBuffersComplete();
+  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->SwapsAreLikelyHighLatency());
+  EXPECT_TRUE(client->HasAction("WillBeginImplFrame"));
+  EXPECT_TRUE(client->HasAction("ScheduledActionSendBeginMainFrame"));
+  EXPECT_TRUE(client->HasAction("ScheduledActionDrawAndSwapIfPossible"));
+}
+
 TEST_F(SchedulerTest, PollForCommitCompletion) {
   // 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(
+  SchedulerClientWithCustomEstimates* client =
+      new SchedulerClientWithCustomEstimates(
           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);
 
   client->set_log_anticipated_draw_time_change(true);
 
   BeginFrameArgs frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src());
@@ skipping 1243 matching lines @@
 
   // At the next BeginFrame, authoritative interval is used instead of previous
   // interval.
   EXPECT_NE(initial_interval, scheduler_->begin_impl_frame_args().interval);
   EXPECT_EQ(authoritative_interval,
             scheduler_->begin_impl_frame_args().interval);
 }
 
 }  // namespace
 }  // namespace cc