cc: Don't recreate lost OutputSurface when hidden

cc/scheduler/scheduler_state_machine_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_state_machine.h"
 
 #include "base/trace_event/trace_event.h"
 #include "cc/scheduler/scheduler.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 34 matching lines @@
     if (state.begin_impl_frame_state() ==                                   \
         SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING) \
       state.OnBeginImplFrameDeadlinePending();                              \
     if (state.begin_impl_frame_state() ==                                   \
         SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)      \
       state.OnBeginImplFrameIdle();                                         \
   }
 
 #define SET_UP_STATE(state)                                         \
   state.SetCanStart();                                              \
+  state.SetVisible(true);                                           \
   EXPECT_ACTION_UPDATE_STATE(                                       \
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION); \
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);   \
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();      \
-  state.SetVisible(true);                                           \
   state.SetCanDraw(true);
 
 namespace cc {
 
 namespace {
 
 void WillPerformAction(SchedulerStateMachine* sm,
                        SchedulerStateMachine::Action action) {
   switch (action) {
     case SchedulerStateMachine::ACTION_NONE:
@@ skipping 129 matching lines @@
 
   using SchedulerStateMachine::ShouldTriggerBeginImplFrameDeadlineImmediately;
   using SchedulerStateMachine::ProactiveBeginFrameWanted;
   using SchedulerStateMachine::WillCommit;
 };
 
 TEST(SchedulerStateMachineTest, BeginFrameNeeded) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
+  state.SetVisible(true);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
   state.SetBeginMainFrameState(
       SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
 
   // Don't request BeginFrames if we are idle.
-  state.SetVisible(true);
   state.SetNeedsRedraw(false);
   state.SetNeedsAnimateForTest(false);
   EXPECT_FALSE(state.BeginFrameNeeded());
 
   // Request BeginFrames if we are ready to draw.
   state.SetVisible(true);
   state.SetNeedsRedraw(true);
   state.SetNeedsAnimateForTest(false);
   EXPECT_TRUE(state.BeginFrameNeeded());
 
@@ skipping 20 matching lines @@
   EXPECT_FALSE(state.BeginFrameNeeded());
 }
 
 TEST(SchedulerStateMachineTest, TestNextActionBeginsMainFrameIfNeeded) {
   SchedulerSettings default_scheduler_settings;
 
   // If no commit needed, do nothing.
   {
     StateMachine state(default_scheduler_settings);
     state.SetCanStart();
+    state.SetVisible(true);
     EXPECT_ACTION_UPDATE_STATE(
         SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
     state.SetBeginMainFrameState(
         SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
     state.SetNeedsRedraw(false);
-    state.SetVisible(true);
 
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     EXPECT_FALSE(state.NeedsCommit());
 
     state.OnBeginImplFrame();
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 
     state.OnBeginImplFrameDeadline();
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     EXPECT_FALSE(state.NeedsCommit());
@@ skipping 18 matching lines @@
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     EXPECT_TRUE(state.NeedsCommit());
   }
 
   // If commit requested, begin a main frame.
   {
     StateMachine state(default_scheduler_settings);
     state.SetBeginMainFrameState(
         SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
     state.SetCanStart();
+    state.SetVisible(true);
     EXPECT_ACTION_UPDATE_STATE(
         SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
     state.SetNeedsRedraw(false);
-    state.SetVisible(true);
     state.SetNeedsBeginMainFrame();
 
     // Expect nothing to happen until after OnBeginImplFrame.
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
     EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
     EXPECT_TRUE(state.NeedsCommit());
     EXPECT_TRUE(state.BeginFrameNeeded());
 
     state.OnBeginImplFrame();
     EXPECT_ACTION_UPDATE_STATE(
         SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
     EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT);
     EXPECT_FALSE(state.NeedsCommit());
   }
 
   // If commit requested and can't draw, still begin a main frame.
   {
     StateMachine state(default_scheduler_settings);
     state.SetBeginMainFrameState(
         SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
     state.SetCanStart();
+    state.SetVisible(true);
     EXPECT_ACTION_UPDATE_STATE(
         SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
     state.SetNeedsRedraw(false);
-    state.SetVisible(true);
     state.SetNeedsBeginMainFrame();
     state.SetCanDraw(false);
 
     // Expect nothing to happen until after OnBeginImplFrame.
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
     EXPECT_IMPL_FRAME_STATE(SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
     EXPECT_TRUE(state.BeginFrameNeeded());
 
     state.OnBeginImplFrame();
@@ skipping 366 matching lines @@
   size_t num_begin_main_frame_states =
       sizeof(begin_main_frame_states) /
       sizeof(SchedulerStateMachine::BeginMainFrameState);
   size_t num_begin_impl_frame_states =
       sizeof(all_begin_impl_frame_states) /
       sizeof(SchedulerStateMachine::BeginImplFrameState);
   for (size_t i = 0; i < num_begin_main_frame_states; ++i) {
     for (size_t j = 0; j < num_begin_impl_frame_states; ++j) {
       StateMachine state(default_scheduler_settings);
       state.SetCanStart();
+      state.SetVisible(true);
       EXPECT_ACTION_UPDATE_STATE(
           SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
       EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
       state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
       state.SetBeginMainFrameState(begin_main_frame_states[i]);
       state.SetBeginImplFrameState(all_begin_impl_frame_states[j]);
       bool visible =
           (all_begin_impl_frame_states[j] !=
            SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);
       state.SetVisible(visible);
 
       // Case 1: needs_begin_main_frame=false
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE,
                 state.NextAction());
 
       // Case 2: needs_begin_main_frame=true
       state.SetNeedsBeginMainFrame();
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE,
                 state.NextAction())
           << state.AsValue()->ToString();
     }
   }
 
   // When in BeginImplFrame deadline we should always draw for SetNeedsRedraw
   // except if we're ready to commit, in which case we expect a commit first.
   for (size_t i = 0; i < num_begin_main_frame_states; ++i) {
     StateMachine state(default_scheduler_settings);
     state.SetCanStart();
+    state.SetVisible(true);
     EXPECT_ACTION_UPDATE_STATE(
         SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
     EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
     state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
     state.SetCanDraw(true);
     state.SetBeginMainFrameState(begin_main_frame_states[i]);
     state.SetBeginImplFrameState(
         SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);
 
     state.SetNeedsRedraw(true);
-    state.SetVisible(true);
 
     SchedulerStateMachine::Action expected_action;
     if (begin_main_frame_states[i] ==
         SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_READY_TO_COMMIT) {
       expected_action = SchedulerStateMachine::ACTION_COMMIT;
     } else {
       expected_action = SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE;
       EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
     }
 
@@ skipping 10 matching lines @@
   SchedulerSettings default_scheduler_settings;
 
   size_t num_begin_main_frame_states =
       sizeof(begin_main_frame_states) /
       sizeof(SchedulerStateMachine::BeginMainFrameState);
   for (size_t i = 0; i < num_begin_main_frame_states; ++i) {
     // There shouldn't be any drawing regardless of BeginImplFrame.
     for (size_t j = 0; j < 2; ++j) {
       StateMachine state(default_scheduler_settings);
       state.SetCanStart();
+      state.SetVisible(true);
       EXPECT_ACTION_UPDATE_STATE(
           SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
       EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
       state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
       state.SetBeginMainFrameState(begin_main_frame_states[i]);
       state.SetVisible(false);
       state.SetNeedsRedraw(true);
       if (j == 1) {
         state.SetBeginImplFrameState(
             SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE);
@@ skipping 16 matching lines @@
   SchedulerSettings default_scheduler_settings;
 
   size_t num_begin_main_frame_states =
       sizeof(begin_main_frame_states) /
       sizeof(SchedulerStateMachine::BeginMainFrameState);
   for (size_t i = 0; i < num_begin_main_frame_states; ++i) {
     // There shouldn't be any drawing regardless of BeginImplFrame.
     for (size_t j = 0; j < 2; ++j) {
       StateMachine state(default_scheduler_settings);
       state.SetCanStart();
+      state.SetVisible(true);
       EXPECT_ACTION_UPDATE_STATE(
           SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
       EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
       state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
       state.SetBeginMainFrameState(begin_main_frame_states[i]);
       state.SetVisible(false);
       state.SetNeedsRedraw(true);
       if (j == 1)
         state.OnBeginImplFrame();
 
       state.SetCanDraw(false);
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_IF_POSSIBLE,
                 state.NextAction());
     }
   }
 }
 
 TEST(SchedulerStateMachineTest,
      TestCanRedrawWithWaitingForFirstDrawMakesProgress) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
+  state.SetVisible(true);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
 
   state.SetActiveTreeNeedsFirstDraw(true);
   state.SetNeedsBeginMainFrame();
   state.SetNeedsRedraw(true);
-  state.SetVisible(true);
   state.SetCanDraw(false);
   state.OnBeginImplFrame();
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ANIMATE);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.NotifyBeginMainFrameStarted();
   state.NotifyReadyToCommit();
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_COMMIT);
@@ skipping 312 matching lines @@
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_IDLE);
   EXPECT_FALSE(state.needs_redraw());
 
   // Next BeginImplFrame should initiate second commit.
   state.OnBeginImplFrame();
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
 }
 
 TEST(SchedulerStateMachineTest, TestRequestCommitInvisible) {

[brianderson, 2015/09/15 18:37:46]

While you are at it, can you rename this test to
TestNoRequestCommitWhenInvisible?

[no sievers, 2015/09/15 20:10:20]

Done.

   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
+  state.SetVisible(true);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
+  state.SetVisible(false);
   state.SetNeedsBeginMainFrame();
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 }
 
+TEST(SchedulerStateMachineTest, TestNoRequestOutputSurfaceWhenInvisible) {
+  SchedulerSettings default_scheduler_settings;
+  StateMachine state(default_scheduler_settings);
+  state.SetCanStart();
+  state.SetVisible(true);

[brianderson, 2015/09/15 18:37:46]

Above this line, can you also check for ACTION_NONE with a comment indicating
that we also shouldn't request an output surface during initialization until we
are visible?

Interestingly, I was just looking at
https://code.google.com/p/chromium/issues/detail?id=163696 doing GPU bug triage.

During tab restore, every new tab creates its contexts simultaneously. This
patch by itself will not change that behavior since, strangely, every Renderer
pulses with SetVisible(true) for a short period during initialization.

If we remove the SetVisible(true) pulse though we could likely reduce the CPU
fighting slightly for the initial tab restore at the cost of first tab switch
responsiveness. I'd be happy with that tradeoff since recent work to improve
session restore has shown that most restored tabs are never looked at.

Should we open up a followup bug?

[no sievers, 2015/09/15 20:10:20]

Done. Note that the default for LayerTreeHost is visible though (unlike the
scheduler) and we will eventually set the scheduler's visibility to match LTH's.
I can make an attempt to change LTH to default to invisible also, which I think
would allow us to remove SetLTHReady/SetCanStart() (since instead you can just
not make it visible then).
Sounds good. I assume LTH defaulting to visible could then actually be part of
the problem here.

+  EXPECT_ACTION_UPDATE_STATE(
+      SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+  state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
+  state.SetVisible(false);
+  state.DidLoseOutputSurface();
+  state.SetNeedsBeginMainFrame();
+  EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
+  state.SetVisible(true);
+  EXPECT_ACTION_UPDATE_STATE(
+      SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
+}
+
 // See ThreadProxy::BeginMainFrame "EarlyOut_NotVisible" /
 // "EarlyOut_OutputSurfaceLost" cases.
 TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseInvisible) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   SET_UP_STATE(state)
 
   // Start clean and set commit.
   state.SetNeedsBeginMainFrame();
 
@@ skipping 38 matching lines @@
   // We should be starting the commit now.
   EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
 }
 
 // See ThreadProxy::BeginMainFrame "EarlyOut_NoUpdates" case.
 TEST(SchedulerStateMachineTest, TestAbortBeginMainFrameBecauseCommitNotNeeded) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
+  state.SetVisible(true);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.DidCreateAndInitializeOutputSurface();
-  state.SetVisible(true);
   state.SetCanDraw(true);
 
   // Get into a begin frame / commit state.
   state.SetNeedsBeginMainFrame();
   state.OnBeginImplFrame();
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
   EXPECT_MAIN_FRAME_STATE(SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT);
   EXPECT_FALSE(state.NeedsCommit());
   EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
@@ skipping 387 matching lines @@
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_ACTIVATE_SYNC_TREE);
 
   EXPECT_TRUE(state.PendingDrawsShouldBeAborted());
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_DRAW_AND_SWAP_ABORT);
 }
 
 TEST(SchedulerStateMachineTest, TestNoBeginFrameNeededWhenInvisible) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
+  state.SetVisible(true);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
-  state.SetVisible(true);
 
   EXPECT_FALSE(state.BeginFrameNeeded());
   state.SetNeedsRedraw(true);
   EXPECT_TRUE(state.BeginFrameNeeded());
 
   state.SetVisible(false);
   EXPECT_FALSE(state.BeginFrameNeeded());
 
   state.SetVisible(true);
   EXPECT_TRUE(state.BeginFrameNeeded());
 }
 
 TEST(SchedulerStateMachineTest, TestNoBeginMainFrameWhenInvisible) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
+  state.SetVisible(true);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
   state.SetVisible(false);
   state.SetNeedsBeginMainFrame();
   EXPECT_ACTION(SchedulerStateMachine::ACTION_NONE);
   EXPECT_FALSE(state.BeginFrameNeeded());
 
   // When become visible again, the needs commit should still be pending.
   state.SetVisible(true);
   EXPECT_TRUE(state.BeginFrameNeeded());
   state.OnBeginImplFrame();
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME);
 }
 
 TEST(SchedulerStateMachineTest, TestFinishCommitWhenCommitInProgress) {
   SchedulerSettings default_scheduler_settings;
   StateMachine state(default_scheduler_settings);
   state.SetCanStart();
+  state.SetVisible(true);
   EXPECT_ACTION_UPDATE_STATE(
       SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION);
   EXPECT_ACTION_UPDATE_STATE(SchedulerStateMachine::ACTION_NONE);
   state.CreateAndInitializeOutputSurfaceWithActivatedCommit();
   state.SetVisible(false);
   state.SetBeginMainFrameState(
       SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT);
   state.SetNeedsBeginMainFrame();
 
   // After the commit completes, activation and draw happen immediately
@@ skipping 331 matching lines @@
   EXPECT_FALSE(state.ProactiveBeginFrameWanted());
   bool commit_has_no_updates = true;
   state.WillCommit(commit_has_no_updates);
   EXPECT_TRUE(state.ProactiveBeginFrameWanted());
   state.OnBeginImplFrame();
   EXPECT_FALSE(state.ProactiveBeginFrameWanted());
 }
 
 }  // namespace
 }  // namespace cc