MessagePump implementations should call DoWork and DoDelayedWork at equal priority

base/message_loop_unittest.cc

Index: base/message_loop_unittest.cc
===================================================================
--- base/message_loop_unittest.cc	(revision 75131)
+++ base/message_loop_unittest.cc	(working copy)
@@ -768,6 +768,18 @@
   bool is_reentrant_;
 };
 
+class RecursiveSlowTask : public RecursiveTask {
+ public:
+  RecursiveSlowTask(int depth, TaskList* order, int cookie, bool is_reentrant)
+      : RecursiveTask(depth, order, cookie, is_reentrant) {
+  }
+
+  virtual void Run() {
+    RecursiveTask::Run();
+    PlatformThread::Sleep(10); // milliseconds

[darin (slow to review), 2011/02/16 23:58:02]

nit: two spaces before '//' for inline comments

+  }
+};
+
 class QuitTask : public OrderedTasks {
  public:
   QuitTask(TaskList* order, int cookie)
@@ -893,6 +905,49 @@
   EXPECT_EQ(order[13], TaskItem(RECURSIVE, 2, false));
 }
 
+void RunTest_RecursiveDenial3(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  EXPECT_TRUE(MessageLoop::current()->NestableTasksAllowed());
+  TaskList order;
+  MessageLoop::current()->PostTask(FROM_HERE,
+                                   new RecursiveSlowTask(2, &order, 1, false));
+  MessageLoop::current()->PostTask(FROM_HERE,
+                                   new RecursiveSlowTask(2, &order, 2, false));
+  MessageLoop::current()->PostDelayedTask(FROM_HERE,
+                                          new OrderedTasks(&order, 3), 5);
+  MessageLoop::current()->PostDelayedTask(FROM_HERE,
+                                          new QuitTask(&order, 4), 5);
+
+  MessageLoop::current()->Run();
+
+  for (size_t i=0; i<order.size(); ++i) {
+    LOG(WARNING) << "item " << i << " is " << order[i];
+  }
+
+  LOG(WARNING) << "message type " << message_loop_type;
+
+  // FIFO order.
+  ASSERT_EQ(16U, order.size());
+  EXPECT_EQ(order[ 0], TaskItem(RECURSIVE, 1, true));
+  EXPECT_EQ(order[ 1], TaskItem(RECURSIVE, 1, false));
+  EXPECT_EQ(order[ 2], TaskItem(RECURSIVE, 2, true));
+  EXPECT_EQ(order[ 3], TaskItem(RECURSIVE, 2, false));
+  EXPECT_EQ(order[ 4], TaskItem(RECURSIVE, 1, true));
+  EXPECT_EQ(order[ 5], TaskItem(RECURSIVE, 1, false));
+  EXPECT_EQ(order[ 6], TaskItem(ORDERERD, 3, true));
+  EXPECT_EQ(order[ 7], TaskItem(ORDERERD, 3, false));
+  EXPECT_EQ(order[ 8], TaskItem(RECURSIVE, 2, true));
+  EXPECT_EQ(order[ 9], TaskItem(RECURSIVE, 2, false));
+  EXPECT_EQ(order[10], TaskItem(QUITMESSAGELOOP, 4, true));
+  EXPECT_EQ(order[11], TaskItem(QUITMESSAGELOOP, 4, false));
+  EXPECT_EQ(order[12], TaskItem(RECURSIVE, 1, true));
+  EXPECT_EQ(order[13], TaskItem(RECURSIVE, 1, false));
+  EXPECT_EQ(order[14], TaskItem(RECURSIVE, 2, true));
+  EXPECT_EQ(order[15], TaskItem(RECURSIVE, 2, false));
+}
+
+
 void RunTest_RecursiveSupport1(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
@@ -1426,6 +1481,12 @@
   RunTest_RecursiveDenial1(MessageLoop::TYPE_IO);
 }
 
+TEST(MessageLoopTest, RecursiveDenial3) {
+  RunTest_RecursiveDenial3(MessageLoop::TYPE_DEFAULT);
+  RunTest_RecursiveDenial3(MessageLoop::TYPE_UI);
+  RunTest_RecursiveDenial3(MessageLoop::TYPE_IO);
+}
+
 TEST(MessageLoopTest, RecursiveSupport1) {
   RunTest_RecursiveSupport1(MessageLoop::TYPE_DEFAULT);
   RunTest_RecursiveSupport1(MessageLoop::TYPE_UI);