MessagePump implementations should call DoWork and DoDelayedWork at equal priority

base/message_loop_unittest.cc

 // Copyright (c) 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 <vector>
 
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/ref_counted.h"
@@ skipping 750 matching lines @@
           new RecursiveTask(depth_ - 1, order(), cookie(), is_reentrant_));
     }
     RunEnd();
   }
 
  private:
   int depth_;
   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)
       : OrderedTasks(order, QUITMESSAGELOOP, cookie) {
   }
 
   virtual void Run() {
     RunStart();
     MessageLoop::current()->Quit();
     RunEnd();
@@ skipping 105 matching lines @@
   EXPECT_EQ(order[ 6], TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order[ 7], TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order[ 8], TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order[ 9], TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order[10], TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order[11], TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order[12], TaskItem(RECURSIVE, 2, true));
   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);
 
   TaskList order;
   MessageLoop::current()->PostTask(FROM_HERE,
                                    new RecursiveTask(2, &order, 1, true));
   MessageLoop::current()->PostTask(FROM_HERE,
                                    new RecursiveTask(2, &order, 2, true));
   MessageLoop::current()->PostTask(FROM_HERE,
                                    new QuitTask(&order, 3));
@@ skipping 513 matching lines @@
   RunTest_Nesting(MessageLoop::TYPE_UI);
   RunTest_Nesting(MessageLoop::TYPE_IO);
 }
 
 TEST(MessageLoopTest, RecursiveDenial1) {
   RunTest_RecursiveDenial1(MessageLoop::TYPE_DEFAULT);
   RunTest_RecursiveDenial1(MessageLoop::TYPE_UI);
   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);
   RunTest_RecursiveSupport1(MessageLoop::TYPE_IO);
 }
 
 #if defined(OS_WIN)
 // This test occasionally hangs http://crbug.com/44567
 TEST(MessageLoopTest, DISABLED_RecursiveDenial2) {
   RunTest_RecursiveDenial2(MessageLoop::TYPE_DEFAULT);
@@ skipping 268 matching lines @@
   loop->PostDelayedTask(
       FROM_HERE,
       new RunAtDestructionTask(&task_destroyed, &destruction_observer_called),
       kDelayMS);
   delete loop;
   EXPECT_TRUE(observer.task_destroyed_before_message_loop());
   // The task should have been destroyed when we deleted the loop.
   EXPECT_TRUE(task_destroyed);
   EXPECT_TRUE(destruction_observer_called);
 }