Cross Reference: /external/chromium_org/cc/scheduler/scheduler

Lines Matching refs:client
21 #define EXPECT_ACTION(action, client, action_index, expected_num_actions) \
23     EXPECT_EQ(expected_num_actions, client.num_actions_());               \
25       ASSERT_LT(action_index, client.num_actions_()) << scheduler;        \
26       EXPECT_STREQ(action, client.Action(action_index));                  \
28     for (int i = expected_num_actions; i < client.num_actions_(); ++i)    \
29       ADD_FAILURE() << "Unexpected action: " << client.Action(i)          \
30                     << " with state:\n" << client.StateForAction(i);      \
33 #define EXPECT_NO_ACTION(client) EXPECT_ACTION("", client, -1, 0)
35 #define EXPECT_SINGLE_ACTION(action, client) \
36   EXPECT_ACTION(action, client, 0, 1)
44                                            FakeSchedulerClient* client);
240                                            FakeSchedulerClient* client) {
252   client->AdvanceFrame();
256   client->task_runner().RunTasksWhile(client->ImplFrameDeadlinePending(true));
261   client->AdvanceFrame();
265   client->task_runner().RunTasksWhile(client->ImplFrameDeadlinePending(true));
270   FakeSchedulerClient client;
272   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
277   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
278   client.Reset();
280   EXPECT_NO_ACTION(client);
284   FakeSchedulerClient client;
286   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
291   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
292   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
295   client.Reset();
297   EXPECT_TRUE(client.needs_begin_frame());
298   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
299   client.Reset();
301   client.AdvanceFrame();
302   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
303   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
305   EXPECT_TRUE(client.needs_begin_frame());
306   client.Reset();
309   client.task_runner().RunPendingTasks();  // Run posted deadline.
310   EXPECT_NO_ACTION(client);
312   EXPECT_TRUE(client.needs_begin_frame());
313   client.Reset();
318   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
319   EXPECT_TRUE(client.needs_begin_frame());
320   client.Reset();
323   client.AdvanceFrame();
324   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
325   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
327   EXPECT_TRUE(client.needs_begin_frame());
328   client.Reset();
331   client.task_runner().RunPendingTasks();  // Run posted deadline.
332   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 1);
334   EXPECT_TRUE(client.needs_begin_frame());
335   client.Reset();
339   client.AdvanceFrame();
340   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
342   client.Reset();
344   client.task_runner().RunPendingTasks();  // Run posted deadline.
345   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
346   EXPECT_FALSE(client.needs_begin_frame());
347   client.Reset();
351   FakeSchedulerClient client;
353   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
358   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
359   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
360   client.Reset();
364   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
366   client.Reset();
367   client.AdvanceFrame();
368   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
369   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
372   EXPECT_TRUE(client.needs_begin_frame());
373   client.Reset();
377   EXPECT_EQ(client.num_actions_(), 0);
378   client.Reset();
383   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
385   client.Reset();
386   client.task_runner().RunPendingTasks();  // Run posted deadline.
387   EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
388   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
393   EXPECT_TRUE(client.needs_begin_frame());
394   client.Reset();
397   client.AdvanceFrame();
398   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
399   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
401   client.Reset();
407   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
409   client.Reset();
410   client.task_runner().RunPendingTasks();  // Run posted deadline.
411   EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
412   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
414   EXPECT_TRUE(client.needs_begin_frame());
415   client.Reset();
419   client.AdvanceFrame();
420   client.task_runner().RunPendingTasks();  // Run posted deadline.
421   EXPECT_FALSE(client.needs_begin_frame());
422   client.Reset();
451   SchedulerClientThatsetNeedsDrawInsideDraw client;
453   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
457   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
458   client.Reset();
462   EXPECT_TRUE(client.needs_begin_frame());
463   EXPECT_EQ(0, client.num_draws());
465   client.AdvanceFrame();
466   client.task_runner().RunPendingTasks();  // Run posted deadline.
467   EXPECT_EQ(1, client.num_draws());
469   EXPECT_TRUE(client.needs_begin_frame());
471   client.AdvanceFrame();
472   client.task_runner().RunPendingTasks();  // Run posted deadline.
473   EXPECT_EQ(2, client.num_draws());
475   EXPECT_TRUE(client.needs_begin_frame());
479   client.AdvanceFrame();
480   client.task_runner().RunPendingTasks();  // Run posted deadline.
481   EXPECT_EQ(2, client.num_draws());
483   EXPECT_FALSE(client.needs_begin_frame());
488   SchedulerClientThatsetNeedsDrawInsideDraw client;
490   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
494   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
495   client.Reset();
497   client.SetDrawWillHappen(false);
501   EXPECT_TRUE(client.needs_begin_frame());
502   EXPECT_EQ(0, client.num_draws());
505   client.AdvanceFrame();
506   client.task_runner().RunPendingTasks();  // Run posted deadline.
507   EXPECT_EQ(1, client.num_draws());
513   EXPECT_TRUE(client.needs_begin_frame());
516   client.AdvanceFrame();
517   client.task_runner().RunPendingTasks();  // Run posted deadline.
518   EXPECT_EQ(2, client.num_draws());
521   EXPECT_TRUE(client.needs_begin_frame());
524   client.SetDrawWillHappen(true);
525   client.AdvanceFrame();
526   client.task_runner().RunPendingTasks();  // Run posted deadline.
527   EXPECT_EQ(3, client.num_draws());
530   EXPECT_TRUE(client.needs_begin_frame());
567   SchedulerClientThatSetNeedsCommitInsideDraw client;
569   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
573   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
574   client.Reset();
576   EXPECT_FALSE(client.needs_begin_frame());
579   EXPECT_EQ(0, client.num_draws());
580   EXPECT_TRUE(client.needs_begin_frame());
582   client.SetNeedsCommitOnNextDraw();
583   client.AdvanceFrame();
584   client.SetNeedsCommitOnNextDraw();
585   client.task_runner().RunPendingTasks();  // Run posted deadline.
586   EXPECT_EQ(1, client.num_draws());
588   EXPECT_TRUE(client.needs_begin_frame());
592   client.AdvanceFrame();
593   client.task_runner().RunPendingTasks();  // Run posted deadline.
594   EXPECT_EQ(2, client.num_draws());
598   EXPECT_TRUE(client.needs_begin_frame());
602   client.AdvanceFrame();
603   client.task_runner().RunPendingTasks();  // Run posted deadline.
604   EXPECT_EQ(2, client.num_draws());
607   EXPECT_FALSE(client.needs_begin_frame());
612   SchedulerClientThatsetNeedsDrawInsideDraw client;
614   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
618   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
619   client.Reset();
621   client.SetDrawWillHappen(false);
625   EXPECT_TRUE(client.needs_begin_frame());
626   EXPECT_EQ(0, client.num_draws());
629   client.AdvanceFrame();
630   client.task_runner().RunPendingTasks();  // Run posted deadline.
631   EXPECT_EQ(1, client.num_draws());
637   EXPECT_TRUE(client.needs_begin_frame());
640   client.AdvanceFrame();
642   client.task_runner().RunPendingTasks();  // Run posted deadline.
643   EXPECT_EQ(2, client.num_draws());
646   EXPECT_TRUE(client.needs_begin_frame());
649   client.SetDrawWillHappen(true);
650   client.AdvanceFrame();
651   client.task_runner().RunPendingTasks();  // Run posted deadline.
652   EXPECT_EQ(3, client.num_draws());
655   EXPECT_TRUE(client.needs_begin_frame());
659   SchedulerClientThatSetNeedsCommitInsideDraw client;
661   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
665   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
666   client.Reset();
670   EXPECT_TRUE(client.needs_begin_frame());
671   EXPECT_EQ(0, client.num_draws());
674   client.SetNeedsCommitOnNextDraw();
675   client.AdvanceFrame();
676   client.task_runner().RunPendingTasks();  // Run posted deadline.
677   EXPECT_EQ(1, client.num_draws());
681   EXPECT_TRUE(client.needs_begin_frame());
684   client.SetDrawWillHappen(false);
685   client.SetNeedsCommitOnNextDraw();
686   client.AdvanceFrame();
687   client.task_runner().RunPendingTasks();  // Run posted deadline.
688   EXPECT_EQ(2, client.num_draws());
702   SchedulerClientNeedsManageTilesInDraw client;
704   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
708   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
712   client.Reset();
717   EXPECT_TRUE(client.needs_begin_frame());
718   EXPECT_EQ(0, client.num_draws());
719   EXPECT_FALSE(client.HasAction("ScheduledActionManageTiles"));
720   EXPECT_FALSE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
724   client.Reset();
725   client.AdvanceFrame();
726   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
727   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
731   client.Reset();
732   client.task_runner().RunPendingTasks();  // Run posted deadline.
733   EXPECT_EQ(1, client.num_draws());
734   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
735   EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
736   EXPECT_LT(client.ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
737             client.ActionIndex("ScheduledActionManageTiles"));
743   client.Reset();
747   EXPECT_TRUE(client.needs_begin_frame());
748   EXPECT_EQ(0, client.num_draws());
752   client.Reset();
753   client.AdvanceFrame();
754   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
755   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
761   client.Reset();
762   client.task_runner().RunPendingTasks();  // Run posted deadline.
763   EXPECT_EQ(1, client.num_draws());
764   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
765   EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
766   EXPECT_LT(client.ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
767             client.ActionIndex("ScheduledActionManageTiles"));
773   client.Reset();
774   client.AdvanceFrame();
775   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
777   client.Reset();
778   client.task_runner().RunPendingTasks();  // Run posted deadline.
779   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
780   EXPECT_FALSE(client.needs_begin_frame());
782   EXPECT_EQ(0, client.num_draws());
786   client.Reset();
787   EXPECT_FALSE(client.needs_begin_frame());
789   EXPECT_TRUE(client.needs_begin_frame());
794   client.Reset();
795   client.AdvanceFrame();
796   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
798   client.Reset();
799   client.task_runner().RunPendingTasks();  // Run posted deadline.
800   EXPECT_EQ(0, client.num_draws());
801   EXPECT_FALSE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
802   EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
809   FakeSchedulerClient client;
811   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
815   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
820   client.Reset();
821   client.AdvanceFrame();
822   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
823   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
830   client.Reset();
831   client.task_runner().RunPendingTasks();  // Run posted deadline.
832   EXPECT_EQ(1, client.num_draws());
833   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
834   EXPECT_FALSE(client.HasAction("ScheduledActionManageTiles"));
842   client.Reset();
843   client.AdvanceFrame();
844   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
845   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
848   client.Reset();
849   client.task_runner().RunPendingTasks();  // Run posted deadline.
850   EXPECT_EQ(1, client.num_draws());
851   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
852   EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
853   EXPECT_LT(client.ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
854             client.ActionIndex("ScheduledActionManageTiles"));
865   client.Reset();
866   client.AdvanceFrame();
867   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
868   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
873   client.Reset();
874   client.task_runner().RunPendingTasks();  // Run posted deadline.
875   EXPECT_EQ(1, client.num_draws());
876   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
877   EXPECT_FALSE(client.HasAction("ScheduledActionManageTiles"));
888   client.Reset();
889   client.AdvanceFrame();
890   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
891   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
896   client.Reset();
897   client.task_runner().RunPendingTasks();  // Run posted deadline.
898   EXPECT_EQ(1, client.num_draws());
899   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
900   EXPECT_FALSE(client.HasAction("ScheduledActionManageTiles"));
907   client.Reset();
908   client.AdvanceFrame();
909   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
910   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
913   client.Reset();
914   client.task_runner().RunPendingTasks();  // Run posted deadline.
915   EXPECT_EQ(1, client.num_draws());
916   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapIfPossible"));
917   EXPECT_TRUE(client.HasAction("ScheduledActionManageTiles"));
918   EXPECT_LT(client.ActionIndex("ScheduledActionDrawAndSwapIfPossible"),
919             client.ActionIndex("ScheduledActionManageTiles"));
927   FakeSchedulerClient client;
930   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
934   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
936   client.SetRedrawWillHappenIfUpdateVisibleTilesHappens(true);
939   client.Reset();
941   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
943   client.Reset();
944   client.AdvanceFrame();
945   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
946   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
949   client.Reset();
952   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
954   client.Reset();
956   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client);
958   client.Reset();
959   client.SetSwapContainsIncompleteTile(true);
960   client.task_runner().RunPendingTasks();  // Run posted deadline.
961   EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
962   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
965   client.Reset();
966   client.AdvanceFrame();
967   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
970   client.Reset();
971   client.task_runner().RunPendingTasks();  // Run posted deadline.
972   EXPECT_ACTION("ScheduledActionUpdateVisibleTiles", client, 0, 3);
973   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 3);
974   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 2, 3);
976   client.Reset();
977   client.AdvanceFrame();
978   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
982   client.Reset();
983   client.task_runner().RunPendingTasks();  // Run posted deadline.
984   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
985   EXPECT_FALSE(client.needs_begin_frame());
989   SchedulerClientNeedsManageTilesInDraw client;
991   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
995   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
997   client.Reset();
999   client.AdvanceFrame();
1003   EXPECT_EQ(base::TimeTicks(), client.posted_begin_impl_frame_deadline());
1037   // Set up client with specified estimates (draw duration is set to 1).
1038   SchedulerClientWithFixedEstimates client(
1044   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
1049   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
1052   client.Reset();
1055   client.AdvanceFrame();
1057   client.task_runner().RunPendingTasks();  // Run posted deadline.
1062   EXPECT_TRUE(client.HasAction("ScheduledActionSendBeginMainFrame"));
1064   client.Reset();
1067   client.AdvanceFrame();
1069   client.task_runner().RunPendingTasks();  // Run posted deadline.
1072   EXPECT_EQ(client.HasAction("ScheduledActionSendBeginMainFrame"),
1078   // Set up client so that estimates indicate that we can commit and activate
1084   // Set up client so that estimates indicate that the commit cannot finish
1090   // Set up client so that estimates indicate that the activate cannot finish
1096   // Set up client so that estimates indicate that we can commit and activate
1103   // Since we are simulating a long commit, set up a client with draw duration
1105   SchedulerClientWithFixedEstimates client(
1109   client.set_log_anticipated_draw_time_change(true);
1111   TestScheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
1124   BeginFrameArgs frame_args = CreateBeginFrameArgsForTesting(client.now_src());
1129   client.task_runner().RunPendingTasks();  // Run posted deadline.
1145   client.task_runner().RunPendingTasks();  // Run posted deadline.
1151   int actions_so_far = client.num_actions_();
1156               client.task_runner().DelayToNextTaskTime().InMicroseconds())
1158     client.task_runner().RunPendingTasks();
1159     EXPECT_GT(client.num_actions_(), actions_so_far);
1160     EXPECT_STREQ(client.Action(client.num_actions_() - 1),
1162     actions_so_far = client.num_actions_();
1169               client.task_runner().DelayToNextTaskTime().InMicroseconds())
1171     client.task_runner().RunPendingTasks();
1172     EXPECT_GT(client.num_actions_(), actions_so_far);
1173     EXPECT_STREQ(client.Action(client.num_actions_() - 1),
1175     actions_so_far = client.num_actions_();
1180   FakeSchedulerClient client;
1182   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
1186   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
1189   client.Reset();
1191   EXPECT_TRUE(client.needs_begin_frame());
1192   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
1193   client.Reset();
1197   BeginFrameArgs args = CreateBeginFrameArgsForTesting(client.now_src());
1200   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1201   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
1203   EXPECT_TRUE(client.needs_begin_frame());
1204   client.Reset();
1213   client.task_runner().RunPendingTasks();  // Run posted deadline.
1214   EXPECT_NO_ACTION(client);
1216   EXPECT_TRUE(client.needs_begin_frame());
1217   client.Reset();
1222   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
1223   EXPECT_TRUE(client.needs_begin_frame());
1224   client.Reset();
1227   client.task_runner().RunPendingTasks();  // Run posted BeginRetroFrame.
1228   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1229   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
1231   EXPECT_TRUE(client.needs_begin_frame());
1232   client.Reset();
1235   client.task_runner().RunPendingTasks();  // Run posted deadline.
1236   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 1);
1238   EXPECT_TRUE(client.needs_begin_frame());
1239   client.Reset();
1243   client.task_runner().RunPendingTasks();  // Run posted BeginRetroFrame.
1244   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
1246   client.Reset();
1248   client.task_runner().RunPendingTasks();  // Run posted deadline.
1249   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
1250   EXPECT_FALSE(client.needs_begin_frame());
1251   client.Reset();
1255   FakeSchedulerClient client;
1257   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
1261   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
1265   client.SetAutomaticSwapAck(false);
1268   client.Reset();
1270   EXPECT_TRUE(client.needs_begin_frame());
1271   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
1272   client.Reset();
1276   BeginFrameArgs args = CreateBeginFrameArgsForTesting(client.now_src());
1279   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1280   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
1282   EXPECT_TRUE(client.needs_begin_frame());
1283   client.Reset();
1289   EXPECT_NO_ACTION(client);
1291   client.Reset();
1296   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
1297   EXPECT_TRUE(client.needs_begin_frame());
1298   client.Reset();
1301   client.task_runner().RunPendingTasks();  // Run posted deadline.
1302   EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
1303   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
1305   EXPECT_TRUE(client.needs_begin_frame());
1306   client.Reset();
1311   client.task_runner().RunPendingTasks();  // Run posted BeginRetroFrame.
1312   EXPECT_ACTION("WillBeginImplFrame", client, 0, 1);
1314   EXPECT_TRUE(client.needs_begin_frame());
1315   client.Reset();
1320   EXPECT_NO_ACTION(client);
1322   EXPECT_TRUE(client.needs_begin_frame());
1323   client.Reset();
1327   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 1);
1329   EXPECT_TRUE(client.needs_begin_frame());
1330   client.Reset();
1335   EXPECT_TRUE(client.task_runner().RunTasksWhile(
1336       client.ImplFrameDeadlinePending(true)));
1338   EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
1339   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
1341   EXPECT_TRUE(client.needs_begin_frame());
1342   client.Reset();
1347   FakeSchedulerClient client;
1352   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
1356   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
1360   client.Reset();
1362   EXPECT_FALSE(client.needs_begin_frame());
1363   EXPECT_NO_ACTION(client);
1364   client.Reset();
1366   // When the client-driven BeginFrame are disabled, the scheduler posts it's
1368   client.task_runner().RunPendingTasks();  // Run posted BeginFrame.
1369   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1370   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
1372   EXPECT_FALSE(client.needs_begin_frame());
1373   client.Reset();
1376   client.task_runner().RunPendingTasks();  // Run posted deadline.
1377   EXPECT_NO_ACTION(client);
1379   EXPECT_FALSE(client.needs_begin_frame());
1380   client.Reset();
1385   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
1386   EXPECT_FALSE(client.needs_begin_frame());
1387   client.Reset();
1390   client.task_runner().RunPendingTasks();  // Run posted BeginFrame.
1391   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1392   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
1394   EXPECT_FALSE(client.needs_begin_frame());
1395   client.Reset();
1398   client.task_runner().RunTasksWhile(client.ImplFrameDeadlinePending(true));
1399   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 1);
1401   EXPECT_FALSE(client.needs_begin_frame());
1402   client.Reset();
1406   client.task_runner().RunPendingTasks();  // Run posted BeginFrame.
1407   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
1409   client.Reset();
1411   // Make sure SetNeedsBeginFrame isn't called on the client
1413   client.task_runner().RunPendingTasks();  // Run posted deadline.
1414   EXPECT_NO_ACTION(client);
1415   EXPECT_FALSE(client.needs_begin_frame());
1416   client.Reset();
1442   FakeSchedulerClient client;
1447   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
1451   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
1455   client.SetAutomaticSwapAck(false);
1458   client.Reset();
1460   EXPECT_FALSE(client.needs_begin_frame());
1461   EXPECT_NO_ACTION(client);
1462   client.Reset();
1465   client.task_runner().RunPendingTasks();  // Run posted BeginFrame.
1466   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1467   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
1469   EXPECT_FALSE(client.needs_begin_frame());
1470   client.Reset();
1475   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
1476   EXPECT_FALSE(client.needs_begin_frame());
1477   client.Reset();
1480   client.task_runner().RunPendingTasks();  // Run posted deadline.
1481   EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
1482   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
1484   EXPECT_FALSE(client.needs_begin_frame());
1485   client.Reset();
1490   client.task_runner().RunPendingTasks();  // Run posted BeginFrame.
1491   EXPECT_ACTION("WillBeginImplFrame", client, 0, 1);
1493   EXPECT_FALSE(client.needs_begin_frame());
1494   client.Reset();
1498   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 1);
1500   EXPECT_FALSE(client.needs_begin_frame());
1501   client.Reset();
1505   client.task_runner().RunPendingTasks();  // Run posted deadline.
1506   EXPECT_ACTION("ScheduledActionAnimate", client, 0, 2);
1507   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 1, 2);
1509   EXPECT_FALSE(client.needs_begin_frame());
1510   client.Reset();
1536   FakeSchedulerClient client;
1538   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
1543   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
1544   client.Reset();
1546   EXPECT_NO_ACTION(client);
1549   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
1553   FakeSchedulerClient client;
1555   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
1560   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
1561   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
1563   client.Reset();
1565   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
1567   client.Reset();
1568   client.AdvanceFrame();
1569   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1570   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
1573   client.Reset();
1576   EXPECT_NO_ACTION(client);
1578   client.Reset();
1581   EXPECT_ACTION("ScheduledActionCommit", client, 0, 1);
1583   client.Reset();
1584   client.task_runner().RunPendingTasks();  // Run posted deadline.
1585   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
1590   FakeSchedulerClient client;
1593   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
1598   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
1599   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
1602   client.Reset();
1604   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
1606   client.Reset();
1607   client.AdvanceFrame();
1608   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1609   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
1612   client.Reset();
1615   EXPECT_NO_ACTION(client);
1617   client.Reset();
1620   client.task_runner().RunTasksWhile(client.ImplFrameDeadlinePending(true));
1623   EXPECT_NO_ACTION(client);
1627   client.task_runner().RunUntilTime(client.now_src()->Now() +
1629   EXPECT_NO_ACTION(client);
1632   client.Reset();
1636     EXPECT_ACTION("ScheduledActionCommit", client, 0, 3);
1637     EXPECT_ACTION("ScheduledActionActivateSyncTree", client, 1, 3);
1638     EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client, 2, 3);
1640     EXPECT_ACTION("ScheduledActionCommit", client, 0, 2);
1641     EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client, 1, 2);
1657   FakeSchedulerClient client;
1660   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
1665   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
1666   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
1669   client.Reset();
1671   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
1673   client.Reset();
1674   client.AdvanceFrame();
1675   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1676   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
1679   client.Reset();
1682   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
1684   client.Reset();
1688     EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client);
1691     EXPECT_NO_ACTION(client);
1694   client.Reset();
1695   client.task_runner().RunPendingTasks();  // Run posted deadline.
1696   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
1708   FakeSchedulerClient client;
1710   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
1714   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
1716   client.Reset();
1719   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
1720   EXPECT_TRUE(client.needs_begin_frame());
1722   client.Reset();
1723   client.AdvanceFrame();
1724   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1725   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
1728   client.Reset();
1730   EXPECT_NO_ACTION(client);
1732   client.Reset();
1733   client.task_runner().RunPendingTasks();  // Run posted deadline.
1734   EXPECT_ACTION("ScheduledActionManageTiles", client, 0, 2);
1735   EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client, 1, 2);
1739   FakeSchedulerClient client;
1741   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
1745   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
1748   client.Reset();
1750   EXPECT_TRUE(client.needs_begin_frame());
1751   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
1755   client.Reset();
1756   BeginFrameArgs args = CreateBeginFrameArgsForTesting(client.now_src());
1759   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1760   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
1762   EXPECT_TRUE(client.needs_begin_frame());
1771   client.Reset();
1772   client.task_runner().RunPendingTasks();  // Run posted deadline.
1773   EXPECT_NO_ACTION(client);
1775   EXPECT_TRUE(client.needs_begin_frame());
1778   client.Reset();
1781   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
1782   EXPECT_TRUE(client.needs_begin_frame());
1784   client.Reset();
1787   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
1788   EXPECT_TRUE(client.needs_begin_frame());
1792   client.Reset();
1793   client.task_runner().RunPendingTasks();
1794   EXPECT_NO_ACTION(client);
1798   FakeSchedulerClient client;
1800   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
1804   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
1807   client.Reset();
1809   EXPECT_TRUE(client.needs_begin_frame());
1810   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
1814   client.Reset();
1815   BeginFrameArgs args = CreateBeginFrameArgsForTesting(client.now_src());
1818   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1819   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
1821   EXPECT_TRUE(client.needs_begin_frame());
1830   client.Reset();
1831   client.task_runner().RunPendingTasks();  // Run posted deadline.
1832   EXPECT_NO_ACTION(client);
1834   EXPECT_TRUE(client.needs_begin_frame());
1837   client.Reset();
1840   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
1841   EXPECT_TRUE(client.needs_begin_frame());
1844   client.Reset();
1845   client.task_runner().RunPendingTasks();  // Run posted BeginRetroFrame.
1846   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1847   EXPECT_ACTION("ScheduledActionAnimate", client, 1, 2);
1849   EXPECT_TRUE(client.needs_begin_frame());
1851   client.Reset();
1854   EXPECT_NO_ACTION(client);
1858   client.Reset();
1859   client.task_runner().RunPendingTasks();  // Run posted deadline.
1860   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
1862   EXPECT_TRUE(client.needs_begin_frame());
1865   client.Reset();
1866   client.task_runner().RunPendingTasks();
1867   EXPECT_NO_ACTION(client);
1872   FakeSchedulerClient client;
1875   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
1879   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
1882   client.Reset();
1887   client.Reset();
1888   client.task_runner().RunPendingTasks();  // Run posted Tick.
1889   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1890   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
1895   client.Reset();
1898   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
1901   client.Reset();
1903   EXPECT_EQ(0, client.num_actions_());
1906   client.Reset();
1907   client.task_runner().RunPendingTasks();  // Run posted deadline.
1908   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
1913   FakeSchedulerClient client;
1916   TestScheduler* scheduler = client.CreateScheduler(scheduler_settings);
1921   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
1922   InitializeOutputSurfaceAndFirstCommit(scheduler, &client);
1925   client.Reset();
1927   EXPECT_SINGLE_ACTION("SetNeedsBeginFrame", client);
1929   client.Reset();
1930   client.AdvanceFrame();
1931   EXPECT_ACTION("WillBeginImplFrame", client, 0, 2);
1932   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 2);
1935   client.Reset();
1938   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
1940   client.Reset();
1943   EXPECT_SINGLE_ACTION("ScheduledActionActivateSyncTree", client);