Cross Reference: /external/chromium_org/base/message_loop/message_loop

Lines Matching refs:order
144   // Test that two tasks with different delays run in the right order.
169   // Test that two tasks with the same delay run in the order in which they
454 void RecursiveFunc(TaskList* order, int cookie, int depth,
456   order->RecordStart(RECURSIVE, cookie);
462         Bind(&RecursiveFunc, order, cookie, depth - 1, is_reentrant));
464   order->RecordEnd(RECURSIVE, cookie);
467 void QuitFunc(TaskList* order, int cookie) {
468   order->RecordStart(QUITMESSAGELOOP, cookie);
470   order->RecordEnd(QUITMESSAGELOOP, cookie);
477   TaskList order;
480       Bind(&RecursiveFunc, &order, 1, 2, false));
483       Bind(&RecursiveFunc, &order, 2, 2, false));
486       Bind(&QuitFunc, &order, 3));
490   // FIFO order.
491   ASSERT_EQ(14U, order.Size());
492   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
493   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
494   EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
495   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
496   EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
497   EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false));
498   EXPECT_EQ(order.Get(6), TaskItem(RECURSIVE, 1, true));
499   EXPECT_EQ(order.Get(7), TaskItem(RECURSIVE, 1, false));
500   EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
501   EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
502   EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true));
503   EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false));
504   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 2, true));
505   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 2, false));
508 void RecursiveSlowFunc(TaskList* order, int cookie, int depth,
510   RecursiveFunc(order, cookie, depth, is_reentrant);
514 void OrderedFunc(TaskList* order, int cookie) {
515   order->RecordStart(ORDERED, cookie);
516   order->RecordEnd(ORDERED, cookie);
524   TaskList order;
526       FROM_HERE, Bind(&RecursiveSlowFunc, &order, 1, 2, false));
528       FROM_HERE, Bind(&RecursiveSlowFunc, &order, 2, 2, false));
531       Bind(&OrderedFunc, &order, 3),
535       Bind(&QuitFunc, &order, 4),
540   // FIFO order.
541   ASSERT_EQ(16U, order.Size());
542   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
543   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
544   EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
545   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
546   EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 1, true));
547   EXPECT_EQ(order.Get(5), TaskItem(RECURSIVE, 1, false));
548   EXPECT_EQ(order.Get(6), TaskItem(ORDERED, 3, true));
549   EXPECT_EQ(order.Get(7), TaskItem(ORDERED, 3, false));
550   EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
551   EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
552   EXPECT_EQ(order.Get(10), TaskItem(QUITMESSAGELOOP, 4, true));
553   EXPECT_EQ(order.Get(11), TaskItem(QUITMESSAGELOOP, 4, false));
554   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 1, true));
555   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 1, false));
556   EXPECT_EQ(order.Get(14), TaskItem(RECURSIVE, 2, true));
557   EXPECT_EQ(order.Get(15), TaskItem(RECURSIVE, 2, false));
564   TaskList order;
566       FROM_HERE, Bind(&RecursiveFunc, &order, 1, 2, true));
568       FROM_HERE, Bind(&RecursiveFunc, &order, 2, 2, true));
570       FROM_HERE, Bind(&QuitFunc, &order, 3));
574   // FIFO order.
575   ASSERT_EQ(14U, order.Size());
576   EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true));
577   EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false));
578   EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true));
579   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
580   EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
581   EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false));
582   EXPECT_EQ(order.Get(6), TaskItem(RECURSIVE, 1, true));
583   EXPECT_EQ(order.Get(7), TaskItem(RECURSIVE, 1, false));
584   EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
585   EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
586   EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true));
587   EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false));
588   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 2, true));
589   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 2, false));
597   TaskList order;
601       Bind(&OrderedFunc, &order, 1));
603                                    Bind(&OrderedFunc, &order, 2));
605                                    Bind(&QuitFunc, &order, 3));
608   // FIFO order.
609   ASSERT_EQ(6U, order.Size());
610   EXPECT_EQ(order.Get(0), TaskItem(ORDERED, 1, true));
611   EXPECT_EQ(order.Get(1), TaskItem(ORDERED, 1, false));
612   EXPECT_EQ(order.Get(2), TaskItem(ORDERED, 2, true));
613   EXPECT_EQ(order.Get(3), TaskItem(ORDERED, 2, false));
614   EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
615   EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false));
618 void FuncThatPumps(TaskList* order, int cookie) {
619   order->RecordStart(PUMPS, cookie);
624   order->RecordEnd(PUMPS, cookie);
627 void SleepFunc(TaskList* order, int cookie, TimeDelta delay) {
628   order->RecordStart(SLEEP, cookie);
630   order->RecordEnd(SLEEP, cookie);
639   TaskList order;
643       Bind(&FuncThatPumps, &order, 1));
647         Bind(&OrderedFunc, &order, 2),
652         Bind(&OrderedFunc, &order, 2));
655                                    Bind(&OrderedFunc, &order, 3));
658       Bind(&SleepFunc, &order, 4, TimeDelta::FromMilliseconds(50)));
660                                    Bind(&OrderedFunc, &order, 5));
664         Bind(&QuitFunc, &order, 6),
669         Bind(&QuitFunc, &order, 6));
674   // FIFO order.
675   ASSERT_EQ(12U, order.Size());
676   EXPECT_EQ(order.Get(0), TaskItem(PUMPS, 1, true));
677   EXPECT_EQ(order.Get(1), TaskItem(ORDERED, 3, true));
678   EXPECT_EQ(order.Get(2), TaskItem(ORDERED, 3, false));
679   EXPECT_EQ(order.Get(3), TaskItem(SLEEP, 4, true));
680   EXPECT_EQ(order.Get(4), TaskItem(SLEEP, 4, false));
681   EXPECT_EQ(order.Get(5), TaskItem(ORDERED, 5, true));
682   EXPECT_EQ(order.Get(6), TaskItem(ORDERED, 5, false));
683   EXPECT_EQ(order.Get(7), TaskItem(PUMPS, 1, false));
684   EXPECT_EQ(order.Get(8), TaskItem(ORDERED, 2, true));
685   EXPECT_EQ(order.Get(9), TaskItem(ORDERED, 2, false));
686   EXPECT_EQ(order.Get(10), TaskItem(QUITMESSAGELOOP, 6, true));
687   EXPECT_EQ(order.Get(11), TaskItem(QUITMESSAGELOOP, 6, false));
690 void FuncThatRuns(TaskList* order, int cookie, RunLoop* run_loop) {
691   order->RecordStart(RUNS, cookie);
696   order->RecordEnd(RUNS, cookie);
707   TaskList order;
712       Bind(&FuncThatRuns, &order, 1, Unretained(&run_loop)));
714       FROM_HERE, Bind(&OrderedFunc, &order, 2));
718       FROM_HERE, Bind(&OrderedFunc, &order, 3));
722       FROM_HERE, Bind(&OrderedFunc, &order, 4)); // never runs
726   ASSERT_EQ(6U, order.Size());
728   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
729   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
730   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
731   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
732   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, true));
733   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, false));
734   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
742   TaskList order;
748       Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
752       FROM_HERE, Bind(&OrderedFunc, &order, 2));
758   ASSERT_EQ(4U, order.Size());
760   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
761   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
762   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
763   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
764   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
772   TaskList order;
778       Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
782       FROM_HERE, Bind(&OrderedFunc, &order, 2));
788   ASSERT_EQ(4U, order.Size());
790   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
791   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
792   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
793   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
794   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
802   TaskList order;
809       Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop)));
813       FROM_HERE, Bind(&OrderedFunc, &order, 2));
821   ASSERT_EQ(4U, order.Size());
823   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
824   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
825   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
826   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
827   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
835   TaskList order;
844       Bind(&FuncThatRuns, &order, 1, Unretained(&nested_loop1)));
846       Bind(&FuncThatRuns, &order, 2, Unretained(&nested_loop2)));
848       Bind(&FuncThatRuns, &order, 3, Unretained(&nested_loop3)));
850       Bind(&FuncThatRuns, &order, 4, Unretained(&nested_loop4)));
852       FROM_HERE, Bind(&OrderedFunc, &order, 5));
856       FROM_HERE, Bind(&OrderedFunc, &order, 6));
860       FROM_HERE, Bind(&OrderedFunc, &order, 7));
864       FROM_HERE, Bind(&OrderedFunc, &order, 8));
868       FROM_HERE, Bind(&OrderedFunc, &order, 9));
872       FROM_HERE, Bind(&OrderedFunc, &order, 10));
876   ASSERT_EQ(18U, order.Size());
878   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
879   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 2, true));
880   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 3, true));
881   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 4, true));
882   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 5, true));
883   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 5, false));
884   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 6, true));
885   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 6, false));
886   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 7, true));
887   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 7, false));
888   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 8, true));
889   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 8, false));
890   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 9, true));
891   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 9, false));
892   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 4, false));
893   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 3, false));
894   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 2, false));
895   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
896   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
904   TaskList order;
911       FROM_HERE, Bind(&OrderedFunc, &order, 1)); // never runs
917   ASSERT_EQ(0U, order.Size());
925   TaskList order;
930       FROM_HERE, Bind(&OrderedFunc, &order, 1));
934       FROM_HERE, Bind(&OrderedFunc, &order, 2)); // never runs
940   ASSERT_EQ(2U, order.Size());
942   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 1, true));
943   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 1, false));
944   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
952   TaskList order;
957       Bind(&FuncThatRuns, &order, 1, Unretained(&run_loop)));
959       FROM_HERE, Bind(&OrderedFunc, &order, 2));
963       FROM_HERE, Bind(&OrderedFunc, &order, 3));
967       FROM_HERE, Bind(&OrderedFunc, &order, 4));
974   ASSERT_EQ(8U, order.Size());
976   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
977   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
978   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
979   EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
980   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, true));
981   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, false));
982   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 4, true));
983   EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 4, false));
984   EXPECT_EQ(static_cast<size_t>(task_index), order.Size());