Add support for base::Closure in the MessageLoop.

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/bind.h"
+#include "base/bind_helpers.h"
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/message_loop.h"

[willchan no longer on Chromium, 2011/02/15 01:41:11]

This should go first.

 #include "base/ref_counted.h"
 #include "base/task.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include "base/message_pump_win.h"
 #include "base/win/scoped_handle.h"
 #endif
@@ skipping 65 matching lines @@
   void QuitNow() {
     MessageLoop::current()->Quit();
   }
 
  private:
   friend class base::RefCounted<QuitMsgLoop>;
 
   ~QuitMsgLoop() {}
 };
 
+void RunTest_PostClosure(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // Add tests to message loop
+  scoped_refptr<Foo> foo(new Foo());
+  std::string a("a"), b("b"), c("c"), d("d");
+  MessageLoop::current()->PostClosure(FROM_HERE, base::Bind(
+      &Foo::Test0, foo.get()));
+  MessageLoop::current()->PostClosure(FROM_HERE, base::Bind(
+    &Foo::Test1ConstRef, foo.get(), a));
+  MessageLoop::current()->PostClosure(FROM_HERE, base::Bind(
+      &Foo::Test1Ptr, foo.get(), &b));
+  MessageLoop::current()->PostClosure(FROM_HERE, base::Bind(
+      &Foo::Test1Int, foo.get(), 100));
+  MessageLoop::current()->PostClosure(FROM_HERE, base::Bind(
+      &Foo::Test2Ptr, foo.get(), &a, &c));
+  MessageLoop::current()->PostClosure(FROM_HERE, base::Bind(
+      &Foo::Test2Mixed, foo.get(), a, &d));
+
+  // After all tests, post a message that will shut down the message loop
+  MessageLoop::current()->PostClosure(FROM_HERE, base::Bind(
+      &MessageLoop::Quit, base::Unretained(MessageLoop::current())));
+
+  // Now kick things off
+  MessageLoop::current()->Run();
+
+  EXPECT_EQ(foo->test_count(), 105);
+  EXPECT_EQ(foo->result(), "abacad");
+}
+
 void RunTest_PostTask(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Add tests to message loop
   scoped_refptr<Foo> foo(new Foo());
   std::string a("a"), b("b"), c("c"), d("d");
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       foo.get(), &Foo::Test0));
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
     foo.get(), &Foo::Test1ConstRef, a));
@@ skipping 11 matching lines @@
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       quit.get(), &QuitMsgLoop::QuitNow));
 
   // Now kick things off
   MessageLoop::current()->Run();
 
   EXPECT_EQ(foo->test_count(), 105);
   EXPECT_EQ(foo->result(), "abacad");
 }
 
+void RunTest_PostClosure_SEH(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // Add tests to message loop
+  scoped_refptr<Foo> foo(new Foo());
+  std::string a("a"), b("b"), c("c"), d("d");
+  MessageLoop::current()->PostClosure(FROM_HERE, base::Bind(
+      &Foo::Test0, foo.get()));
+  MessageLoop::current()->PostClosure(FROM_HERE, base::Bind(
+      &Foo::Test1ConstRef,foo.get(), a));
+  MessageLoop::current()->PostClosure(FROM_HERE, base::Bind(
+      &Foo::Test1Ptr,foo.get(), &b));
+  MessageLoop::current()->PostClosure(FROM_HERE, base::Bind(
+      &Foo::Test1Int,foo.get(), 100));
+  MessageLoop::current()->PostClosure(FROM_HERE, base::Bind(
+      &Foo::Test2Ptr,foo.get(), &a, &c));
+  MessageLoop::current()->PostClosure(FROM_HERE, base::Bind(
+      &Foo::Test2Mixed,foo.get(), a, &d));
+
+  // After all tests, post a message that will shut down the message loop
+  MessageLoop::current()->PostClosure(FROM_HERE, base::Bind(
+      &MessageLoop::Quit, base::Unretained(MessageLoop::current())));
+
+  // Now kick things off with the SEH block active.
+  MessageLoop::current()->set_exception_restoration(true);
+  MessageLoop::current()->Run();
+  MessageLoop::current()->set_exception_restoration(false);
+
+  EXPECT_EQ(foo->test_count(), 105);
+  EXPECT_EQ(foo->result(), "abacad");
+}
+
 void RunTest_PostTask_SEH(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Add tests to message loop
   scoped_refptr<Foo> foo(new Foo());
   std::string a("a"), b("b"), c("c"), d("d");
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       foo.get(), &Foo::Test0));
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       foo.get(), &Foo::Test1ConstRef, a));
@@ skipping 13 matching lines @@
 
   // Now kick things off with the SEH block active.
   MessageLoop::current()->set_exception_restoration(true);
   MessageLoop::current()->Run();
   MessageLoop::current()->set_exception_restoration(false);
 
   EXPECT_EQ(foo->test_count(), 105);
   EXPECT_EQ(foo->result(), "abacad");
 }
 
+// This Func runs slowly to simulate a large amount of work being done.
+static void SlowFunc(int pause_ms, int* quit_counter) {
+    PlatformThread::Sleep(pause_ms);
+    if (--(*quit_counter) == 0)
+      MessageLoop::current()->Quit();
+}
+
 // This class runs slowly to simulate a large amount of work being done.
 class SlowTask : public Task {
  public:
   SlowTask(int pause_ms, int* quit_counter)
       : pause_ms_(pause_ms), quit_counter_(quit_counter) {
   }
   virtual void Run() {
-    PlatformThread::Sleep(pause_ms_);
-    if (--(*quit_counter_) == 0)
-      MessageLoop::current()->Quit();
+    SlowFunc(pause_ms_, quit_counter_);
   }
  private:
   int pause_ms_;
   int* quit_counter_;
 };
 
 // This class records the time when Run was called in a Time object, which is
 // useful for building a variety of MessageLoop tests.
-class RecordRunTimeTask : public SlowTask {
+static void RecordRunTimeFunc(Time* run_time, int* quit_counter) {
+  *run_time = Time::Now();
+
+    // Cause our Run function to take some time to execute.  As a result we can
+    // count on subsequent RecordRunTimeFunc()s running at a future time,
+    // without worry about the resolution of our system clock being an issue.
+  SlowFunc(10, quit_counter);
+}
+
+// This class records the time when Run was called in a Time object, which is
+// useful for building a variety of MessageLoop tests.
+class RecordRunTimeTask : public Task {
  public:
   RecordRunTimeTask(Time* run_time, int* quit_counter)
-      : SlowTask(10, quit_counter), run_time_(run_time) {
+      : run_time_(run_time), quit_counter_(quit_counter) {
   }
   virtual void Run() {
-    *run_time_ = Time::Now();
-    // Cause our Run function to take some time to execute.  As a result we can
-    // count on subsequent RecordRunTimeTask objects running at a future time,
-    // without worry about the resolution of our system clock being an issue.
-    SlowTask::Run();
+    RecordRunTimeFunc(run_time_, quit_counter_);
   }
  private:
   Time* run_time_;
+  int* quit_counter_;
 };
 
+void RunTest_PostDelayedClosure_Basic(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // Test that PostDelayedClosureTask results in a delayed task.
+
+  const int kDelayMS = 100;
+
+  int num_tasks = 1;
+  Time run_time;
+
+  loop.PostDelayedClosure(
+      FROM_HERE, base::Bind(&RecordRunTimeFunc, &run_time, &num_tasks),
+      kDelayMS);
+
+  Time time_before_run = Time::Now();
+  loop.Run();
+  Time time_after_run = Time::Now();
+
+  EXPECT_EQ(0, num_tasks);
+  EXPECT_LT(kDelayMS, (time_after_run - time_before_run).InMilliseconds());
+}
+
 void RunTest_PostDelayedTask_Basic(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Test that PostDelayedTask results in a delayed task.
 
   const int kDelayMS = 100;
 
   int num_tasks = 1;
   Time run_time;
 
   loop.PostDelayedTask(
       FROM_HERE, new RecordRunTimeTask(&run_time, &num_tasks), kDelayMS);
 
   Time time_before_run = Time::Now();
   loop.Run();
   Time time_after_run = Time::Now();
 
   EXPECT_EQ(0, num_tasks);
   EXPECT_LT(kDelayMS, (time_after_run - time_before_run).InMilliseconds());
 }
 
+void RunTest_PostDelayedClosure_InDelayOrder(
+    MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // Test that two tasks with different delays run in the right order.
+
+  int num_tasks = 2;
+  Time run_time1, run_time2;
+
+  loop.PostDelayedClosure(
+      FROM_HERE, base::Bind(&RecordRunTimeFunc, &run_time1, &num_tasks), 200);
+  // If we get a large pause in execution (due to a context switch) here, this
+  // test could fail.
+  loop.PostDelayedClosure(
+      FROM_HERE, base::Bind(&RecordRunTimeFunc, &run_time2, &num_tasks), 10);
+
+  loop.Run();
+  EXPECT_EQ(0, num_tasks);
+
+  EXPECT_TRUE(run_time2 < run_time1);
+}
+
 void RunTest_PostDelayedTask_InDelayOrder(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Test that two tasks with different delays run in the right order.
 
   int num_tasks = 2;
   Time run_time1, run_time2;
 
   loop.PostDelayedTask(
       FROM_HERE, new RecordRunTimeTask(&run_time1, &num_tasks), 200);
   // If we get a large pause in execution (due to a context switch) here, this
   // test could fail.
   loop.PostDelayedTask(
       FROM_HERE, new RecordRunTimeTask(&run_time2, &num_tasks), 10);
 
   loop.Run();
   EXPECT_EQ(0, num_tasks);
 
   EXPECT_TRUE(run_time2 < run_time1);
 }
 
+void RunTest_PostDelayedClosure_InPostOrder(
+    MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // Test that two tasks with the same delay run in the order in which they
+  // were posted.
+  //
+  // NOTE: This is actually an approximate test since the API only takes a
+  // "delay" parameter, so we are not exactly simulating two tasks that get
+  // posted at the exact same time.  It would be nice if the API allowed us to
+  // specify the desired run time.
+
+  const int kDelayMS = 100;
+
+  int num_tasks = 2;
+  Time run_time1, run_time2;
+
+  loop.PostDelayedClosure(
+      FROM_HERE,
+      base::Bind(&RecordRunTimeFunc, &run_time1, &num_tasks),
+      kDelayMS);
+  loop.PostDelayedClosure(
+      FROM_HERE,
+      base::Bind(&RecordRunTimeFunc, &run_time2, &num_tasks),
+      kDelayMS);
+
+  loop.Run();
+  EXPECT_EQ(0, num_tasks);
+
+  EXPECT_TRUE(run_time1 < run_time2);
+}
+
 void RunTest_PostDelayedTask_InPostOrder(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Test that two tasks with the same delay run in the order in which they
   // were posted.
   //
   // NOTE: This is actually an approximate test since the API only takes a
   // "delay" parameter, so we are not exactly simulating two tasks that get
   // posted at the exact same time.  It would be nice if the API allowed us to
   // specify the desired run time.
 
   const int kDelayMS = 100;
 
   int num_tasks = 2;
   Time run_time1, run_time2;
 
   loop.PostDelayedTask(
       FROM_HERE, new RecordRunTimeTask(&run_time1, &num_tasks), kDelayMS);
   loop.PostDelayedTask(
       FROM_HERE, new RecordRunTimeTask(&run_time2, &num_tasks), kDelayMS);
 
   loop.Run();
   EXPECT_EQ(0, num_tasks);
 
   EXPECT_TRUE(run_time1 < run_time2);
 }
 
+void RunTest_PostDelayedClosure_InPostOrder_2(
+    MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // Test that a delayed task still runs after a normal tasks even if the
+  // normal tasks take a long time to run.
+
+  const int kPauseMS = 50;
+
+  int num_tasks = 2;
+  Time run_time;
+
+  loop.PostClosure(
+      FROM_HERE, base::Bind(&SlowFunc, kPauseMS, &num_tasks));
+  loop.PostDelayedClosure(
+      FROM_HERE, base::Bind(&RecordRunTimeFunc, &run_time, &num_tasks), 10);
+
+  Time time_before_run = Time::Now();
+  loop.Run();
+  Time time_after_run = Time::Now();
+
+  EXPECT_EQ(0, num_tasks);
+
+  EXPECT_LT(kPauseMS, (time_after_run - time_before_run).InMilliseconds());
+}
+
 void RunTest_PostDelayedTask_InPostOrder_2(
     MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Test that a delayed task still runs after a normal tasks even if the
   // normal tasks take a long time to run.
 
   const int kPauseMS = 50;
 
   int num_tasks = 2;
   Time run_time;
 
   loop.PostTask(
       FROM_HERE, new SlowTask(kPauseMS, &num_tasks));
   loop.PostDelayedTask(
       FROM_HERE, new RecordRunTimeTask(&run_time, &num_tasks), 10);
 
   Time time_before_run = Time::Now();
   loop.Run();
   Time time_after_run = Time::Now();
 
   EXPECT_EQ(0, num_tasks);
 
   EXPECT_LT(kPauseMS, (time_after_run - time_before_run).InMilliseconds());
 }
 
+void RunTest_PostDelayedClosure_InPostOrder_3(
+    MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // Test that a delayed task still runs after a pile of normal tasks.  The key
+  // difference between this test and the previous one is that here we return
+  // the MessageLoop a lot so we give the MessageLoop plenty of opportunities
+  // to maybe run the delayed task.  It should know not to do so until the
+  // delayed task's delay has passed.
+
+  int num_tasks = 11;
+  Time run_time1, run_time2;
+
+  // Clutter the ML with tasks.
+  for (int i = 1; i < num_tasks; ++i)
+    loop.PostClosure(FROM_HERE,
+                     base::Bind(&RecordRunTimeFunc, &run_time1, &num_tasks));
+
+  loop.PostDelayedClosure(
+      FROM_HERE, base::Bind(&RecordRunTimeFunc, &run_time2, &num_tasks), 1);
+
+  loop.Run();
+  EXPECT_EQ(0, num_tasks);
+
+  EXPECT_TRUE(run_time2 > run_time1);
+}
+
 void RunTest_PostDelayedTask_InPostOrder_3(
     MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Test that a delayed task still runs after a pile of normal tasks.  The key
   // difference between this test and the previous one is that here we return
   // the MessageLoop a lot so we give the MessageLoop plenty of opportunities
   // to maybe run the delayed task.  It should know not to do so until the
   // delayed task's delay has passed.
 
   int num_tasks = 11;
   Time run_time1, run_time2;
 
   // Clutter the ML with tasks.
   for (int i = 1; i < num_tasks; ++i)
     loop.PostTask(FROM_HERE, new RecordRunTimeTask(&run_time1, &num_tasks));
 
   loop.PostDelayedTask(
       FROM_HERE, new RecordRunTimeTask(&run_time2, &num_tasks), 1);
 
   loop.Run();
   EXPECT_EQ(0, num_tasks);
 
   EXPECT_TRUE(run_time2 > run_time1);
 }
 
+void RunTest_PostDelayedClosure_SharedTimer(
+    MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // Test that the interval of the timer, used to run the next delayed task, is
+  // set to a value corresponding to when the next delayed task should run.
+
+  // By setting num_tasks to 1, we ensure that the first task to run causes the
+  // run loop to exit.
+  int num_tasks = 1;
+  Time run_time1, run_time2;
+
+  loop.PostDelayedClosure(
+      FROM_HERE,
+      base::Bind(&RecordRunTimeFunc, &run_time1, &num_tasks),
+      1000000);
+  loop.PostDelayedClosure(
+      FROM_HERE, base::Bind(&RecordRunTimeFunc, &run_time2, &num_tasks), 10);
+
+  Time start_time = Time::Now();
+
+  loop.Run();
+  EXPECT_EQ(0, num_tasks);
+
+  // Ensure that we ran in far less time than the slower timer.
+  TimeDelta total_time = Time::Now() - start_time;
+  EXPECT_GT(5000, total_time.InMilliseconds());
+
+  // In case both timers somehow run at nearly the same time, sleep a little
+  // and then run all pending to force them both to have run.  This is just
+  // encouraging flakiness if there is any.
+  PlatformThread::Sleep(100);
+  loop.RunAllPending();
+
+  EXPECT_TRUE(run_time1.is_null());
+  EXPECT_FALSE(run_time2.is_null());
+}
+
 void RunTest_PostDelayedTask_SharedTimer(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   // Test that the interval of the timer, used to run the next delayed task, is
   // set to a value corresponding to when the next delayed task should run.
 
   // By setting num_tasks to 1, we ensure that the first task to run causes the
   // run loop to exit.
   int num_tasks = 1;
   Time run_time1, run_time2;
@@ skipping 17 matching lines @@
   // encouraging flakiness if there is any.
   PlatformThread::Sleep(100);
   loop.RunAllPending();
 
   EXPECT_TRUE(run_time1.is_null());
   EXPECT_FALSE(run_time2.is_null());
 }
 
 #if defined(OS_WIN)
 
+void SubPumpFunc() {
+  MessageLoop::current()->SetNestableTasksAllowed(true);
+  MSG msg;
+  while (GetMessage(&msg, NULL, 0, 0)) {
+    TranslateMessage(&msg);
+    DispatchMessage(&msg);
+  }
+  MessageLoop::current()->Quit();
+}
+
 class SubPumpTask : public Task {
  public:
   virtual void Run() {
-    MessageLoop::current()->SetNestableTasksAllowed(true);
-    MSG msg;
-    while (GetMessage(&msg, NULL, 0, 0)) {
-      TranslateMessage(&msg);
-      DispatchMessage(&msg);
-    }
-    MessageLoop::current()->Quit();
+    SubPumpFunc();
   }
 };
 
 class SubPumpQuitTask : public Task {
  public:
   SubPumpQuitTask() {
   }
   virtual void Run() {
     PostQuitMessage(0);
   }
 };
 
+// Workaround base::Bind not support __stdcall.
+//
+// TODO(ajwong): Add support for platform specific function types into Bind.
+void DoPostQuitMessage(int n) {
+  PostQuitMessage(n);
+}
+
+void RunTest_PostDelayedClosure_SharedTimer_SubPump() {
+  MessageLoop loop(MessageLoop::TYPE_UI);
+
+  // Test that the interval of the timer, used to run the next delayed task, is
+  // set to a value corresponding to when the next delayed task should run.
+
+  // By setting num_tasks to 1, we ensure that the first task to run causes the
+  // run loop to exit.
+  int num_tasks = 1;
+  Time run_time;
+
+  loop.PostClosure(FROM_HERE, base::Bind(&SubPumpFunc));
+
+  // This very delayed task should never run.
+  loop.PostDelayedClosure(
+      FROM_HERE,
+      base::Bind(&RecordRunTimeFunc, &run_time, &num_tasks),
+      1000000);
+
+  // This slightly delayed task should run from within SubPumpTask::Run().
+  loop.PostDelayedClosure(FROM_HERE, base::Bind(&DoPostQuitMessage, 0), 10);
+
+  Time start_time = Time::Now();
+
+  loop.Run();
+  EXPECT_EQ(1, num_tasks);
+
+  // Ensure that we ran in far less time than the slower timer.
+  TimeDelta total_time = Time::Now() - start_time;
+  EXPECT_GT(5000, total_time.InMilliseconds());
+
+  // In case both timers somehow run at nearly the same time, sleep a little
+  // and then run all pending to force them both to have run.  This is just
+  // encouraging flakiness if there is any.
+  PlatformThread::Sleep(100);
+  loop.RunAllPending();
+
+  EXPECT_TRUE(run_time.is_null());
+}
+
 void RunTest_PostDelayedTask_SharedTimer_SubPump() {
   MessageLoop loop(MessageLoop::TYPE_UI);
 
   // Test that the interval of the timer, used to run the next delayed task, is
   // set to a value corresponding to when the next delayed task should run.
 
   // By setting num_tasks to 1, we ensure that the first task to run causes the
   // run loop to exit.
   int num_tasks = 1;
   Time run_time;
@@ skipping 67 matching lines @@
     RecordDeletionTask* a = new RecordDeletionTask(NULL, &a_was_deleted);
     RecordDeletionTask* b = new RecordDeletionTask(a, &b_was_deleted);
     RecordDeletionTask* c = new RecordDeletionTask(b, &c_was_deleted);
     loop.PostTask(FROM_HERE, c);
   }
   EXPECT_TRUE(a_was_deleted);
   EXPECT_TRUE(b_was_deleted);
   EXPECT_TRUE(c_was_deleted);
 }
 
+void NestingFunc(int* depth) {
+  if (*depth > 0) {
+    *depth -= 1;
+    MessageLoop::current()->PostClosure(FROM_HERE,
+                                        base::Bind(&NestingFunc, depth));
+
+    MessageLoop::current()->SetNestableTasksAllowed(true);
+    MessageLoop::current()->Run();
+  }
+  MessageLoop::current()->Quit();
+}
+
 class NestingTest : public Task {
  public:
   explicit NestingTest(int* depth) : depth_(depth) {
   }
   void Run() {
     if (*depth_ > 0) {
       *depth_ -= 1;
       MessageLoop::current()->PostTask(FROM_HERE, new NestingTest(depth_));
 
       MessageLoop::current()->SetNestableTasksAllowed(true);
@@ skipping 111 matching lines @@
   MessageLoop::current()->PostTask(FROM_HERE, new CrasherTask(true));
   MessageLoop::current()->set_exception_restoration(true);
   MessageLoop::current()->Run();
   MessageLoop::current()->set_exception_restoration(false);
 
   ::SetUnhandledExceptionFilter(old_SEH_filter);
 }
 
 #endif  // defined(OS_WIN)
 
+void RunTest_NestingClosure(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  int depth = 100;
+  MessageLoop::current()->PostClosure(FROM_HERE,
+                                      base::Bind(&NestingFunc, &depth));
+  MessageLoop::current()->Run();
+  EXPECT_EQ(depth, 0);
+}
+
 void RunTest_Nesting(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   int depth = 100;
   MessageLoop::current()->PostTask(FROM_HERE, new NestingTest(&depth));
   MessageLoop::current()->Run();
   EXPECT_EQ(depth, 0);
 }
 
 const wchar_t* const kMessageBoxTitle = L"MessageLoop Unit Test";
@@ skipping 254 matching lines @@
  private:
   MessageLoop* target_;
   HANDLE event_;
   TaskList* order_;
   bool expect_window_;
   bool is_reentrant_;
 };
 
 #endif  // defined(OS_WIN)
 
+void RunTest_RecursiveDenialClosure1(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  EXPECT_TRUE(MessageLoop::current()->NestableTasksAllowed());
+  TaskList order;
+  RecursiveTask recursive1(2, &order, 1, false);
+  RecursiveTask recursive2(2, &order, 2, false);
+  QuitTask quit_task(&order, 3);
+  MessageLoop::current()->PostClosure(
+      FROM_HERE,
+      base::Bind(&RecursiveTask::Run, base::Unretained(&recursive1)));
+  MessageLoop::current()->PostClosure(
+      FROM_HERE,
+      base::Bind(&RecursiveTask::Run, base::Unretained(&recursive2)));
+  MessageLoop::current()->PostClosure(
+      FROM_HERE,
+      base::Bind(&QuitTask::Run, base::Unretained(&quit_task)));
+
+  MessageLoop::current()->Run();
+
+  // FIFO order.
+  ASSERT_EQ(14U, 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(QUITMESSAGELOOP, 3, true));
+  EXPECT_EQ(order[ 5], TaskItem(QUITMESSAGELOOP, 3, false));
+  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_RecursiveDenial1(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   EXPECT_TRUE(MessageLoop::current()->NestableTasksAllowed());
   TaskList order;
   MessageLoop::current()->PostTask(FROM_HERE,
                                    new RecursiveTask(2, &order, 1, false));
   MessageLoop::current()->PostTask(FROM_HERE,
                                    new RecursiveTask(2, &order, 2, false));
   MessageLoop::current()->PostTask(FROM_HERE, new QuitTask(&order, 3));
@@ skipping 11 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_RecursiveSupportClosure1(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+  RecursiveTask recursive1(2, &order, 1, true);
+  RecursiveTask recursive2(2, &order, 2, true);
+  QuitTask quit_task(&order, 3);
+  MessageLoop::current()->PostClosure(
+      FROM_HERE,
+      base::Bind(&RecursiveTask::Run, base::Unretained(&recursive1)));
+  MessageLoop::current()->PostClosure(
+      FROM_HERE,
+      base::Bind(&RecursiveTask::Run, base::Unretained(&recursive2)));
+  MessageLoop::current()->PostClosure(
+      FROM_HERE,
+      base::Bind(&QuitTask::Run, base::Unretained(&quit_task)));
+
+  MessageLoop::current()->Run();
+
+  // FIFO order.
+  ASSERT_EQ(14U, 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(QUITMESSAGELOOP, 3, true));
+  EXPECT_EQ(order[ 5], TaskItem(QUITMESSAGELOOP, 3, false));
+  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_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 124 matching lines @@
     RunStart();
     bool old_state = MessageLoop::current()->NestableTasksAllowed();
     MessageLoop::current()->SetNestableTasksAllowed(true);
     MessageLoop::current()->RunAllPending();
     MessageLoop::current()->SetNestableTasksAllowed(old_state);
     RunEnd();
   }
 };
 
 // Tests that non nestable tasks run in FIFO if there are no nested loops.
+void RunTest_NonNestableClosureWithNoNesting(
+    MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  OrderedTasks order1(&order, 1);
+  OrderedTasks order2(&order, 2);
+  QuitTask quit_task(&order, 3);
+  MessageLoop::current()->PostNonNestableClosure(
+      FROM_HERE,
+      base::Bind(&OrderedTasks::Run, base::Unretained(&order1)));
+  MessageLoop::current()->PostClosure(
+      FROM_HERE,
+      base::Bind(&OrderedTasks::Run, base::Unretained(&order2)));
+  MessageLoop::current()->PostClosure(
+      FROM_HERE,
+      base::Bind(&QuitTask::Run, base::Unretained(&quit_task)));
+  MessageLoop::current()->Run();
+
+  // FIFO order.
+  ASSERT_EQ(6U, order.size());
+  EXPECT_EQ(order[ 0], TaskItem(ORDERERD, 1, true));
+  EXPECT_EQ(order[ 1], TaskItem(ORDERERD, 1, false));
+  EXPECT_EQ(order[ 2], TaskItem(ORDERERD, 2, true));
+  EXPECT_EQ(order[ 3], TaskItem(ORDERERD, 2, false));
+  EXPECT_EQ(order[ 4], TaskItem(QUITMESSAGELOOP, 3, true));
+  EXPECT_EQ(order[ 5], TaskItem(QUITMESSAGELOOP, 3, false));
+}
+
+// Tests that non nestable tasks run in FIFO if there are no nested loops.
 void RunTest_NonNestableWithNoNesting(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
   Task* task = new OrderedTasks(&order, 1);
   MessageLoop::current()->PostNonNestableTask(FROM_HERE, task);
   MessageLoop::current()->PostTask(FROM_HERE, new OrderedTasks(&order, 2));
   MessageLoop::current()->PostTask(FROM_HERE, new QuitTask(&order, 3));
   MessageLoop::current()->Run();
 
   // FIFO order.
   ASSERT_EQ(6U, order.size());
   EXPECT_EQ(order[ 0], TaskItem(ORDERERD, 1, true));
   EXPECT_EQ(order[ 1], TaskItem(ORDERERD, 1, false));
   EXPECT_EQ(order[ 2], TaskItem(ORDERERD, 2, true));
   EXPECT_EQ(order[ 3], TaskItem(ORDERERD, 2, false));
   EXPECT_EQ(order[ 4], TaskItem(QUITMESSAGELOOP, 3, true));
   EXPECT_EQ(order[ 5], TaskItem(QUITMESSAGELOOP, 3, false));
 }
 
 // Tests that non nestable tasks don't run when there's code in the call stack.
+void RunTest_NonNestableClosureInNestedLoop(
+    MessageLoop::Type message_loop_type,
+    bool use_delayed) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  TaskThatPumps task_that_pumps(&order, 1);
+  MessageLoop::current()->PostClosure(
+      FROM_HERE,
+      base::Bind(&TaskThatPumps::Run, base::Unretained(&task_that_pumps)));
+  OrderedTasks ordered1(&order, 2);
+  if (use_delayed) {
+    MessageLoop::current()->PostNonNestableDelayedClosure(
+        FROM_HERE,
+        base::Bind(&OrderedTasks::Run, base::Unretained(&ordered1)),
+        1);
+  } else {
+    MessageLoop::current()->PostNonNestableClosure(
+        FROM_HERE,
+        base::Bind(&OrderedTasks::Run, base::Unretained(&ordered1)));
+  }
+  OrderedTasks ordered3(&order, 3);
+  SleepTask sleep_task(&order, 4, 50);
+  OrderedTasks ordered5(&order, 5);
+  QuitTask quit_task(&order, 6);
+  MessageLoop::current()->PostClosure(
+      FROM_HERE,
+      base::Bind(&OrderedTasks::Run, base::Unretained(&ordered3)));
+  MessageLoop::current()->PostClosure(
+      FROM_HERE,
+      base::Bind(&SleepTask::Run, base::Unretained(&sleep_task)));
+  MessageLoop::current()->PostClosure(
+      FROM_HERE,
+      base::Bind(&OrderedTasks::Run, base::Unretained(&ordered5)));
+  if (use_delayed) {
+    MessageLoop::current()->PostNonNestableDelayedClosure(
+        FROM_HERE,
+        base::Bind(&QuitTask::Run, base::Unretained(&quit_task)),
+        2);
+  } else {
+    MessageLoop::current()->PostNonNestableClosure(
+        FROM_HERE,
+        base::Bind(&QuitTask::Run, base::Unretained(&quit_task)));
+  }
+
+  MessageLoop::current()->Run();
+
+  // FIFO order.
+  ASSERT_EQ(12U, order.size());
+  EXPECT_EQ(order[ 0], TaskItem(PUMPS, 1, true));
+  EXPECT_EQ(order[ 1], TaskItem(ORDERERD, 3, true));
+  EXPECT_EQ(order[ 2], TaskItem(ORDERERD, 3, false));
+  EXPECT_EQ(order[ 3], TaskItem(SLEEP, 4, true));
+  EXPECT_EQ(order[ 4], TaskItem(SLEEP, 4, false));
+  EXPECT_EQ(order[ 5], TaskItem(ORDERERD, 5, true));
+  EXPECT_EQ(order[ 6], TaskItem(ORDERERD, 5, false));
+  EXPECT_EQ(order[ 7], TaskItem(PUMPS, 1, false));
+  EXPECT_EQ(order[ 8], TaskItem(ORDERERD, 2, true));
+  EXPECT_EQ(order[ 9], TaskItem(ORDERERD, 2, false));
+  EXPECT_EQ(order[10], TaskItem(QUITMESSAGELOOP, 6, true));
+  EXPECT_EQ(order[11], TaskItem(QUITMESSAGELOOP, 6, false));
+}
+
+// Tests that non nestable tasks don't run when there's code in the call stack.
 void RunTest_NonNestableInNestedLoop(MessageLoop::Type message_loop_type,
                                      bool use_delayed) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
   MessageLoop::current()->PostTask(FROM_HERE,
                                    new TaskThatPumps(&order, 1));
   Task* task = new OrderedTasks(&order, 2);
   if (use_delayed) {
@@ skipping 249 matching lines @@
 
 #endif  // defined(OS_WIN)
 
 }  // namespace
 
 //-----------------------------------------------------------------------------
 // Each test is run against each type of MessageLoop.  That way we are sure
 // that message loops work properly in all configurations.  Of course, in some
 // cases, a unit test may only be for a particular type of loop.
 
+TEST(MessageLoopTest, PostClosure) {
+  RunTest_PostClosure(MessageLoop::TYPE_DEFAULT);
+  RunTest_PostClosure(MessageLoop::TYPE_UI);
+  RunTest_PostClosure(MessageLoop::TYPE_IO);
+}
+
 TEST(MessageLoopTest, PostTask) {
   RunTest_PostTask(MessageLoop::TYPE_DEFAULT);
   RunTest_PostTask(MessageLoop::TYPE_UI);
   RunTest_PostTask(MessageLoop::TYPE_IO);
 }
 
+TEST(MessageLoopTest, PostClosure_SEH) {
+  RunTest_PostClosure_SEH(MessageLoop::TYPE_DEFAULT);
+  RunTest_PostClosure_SEH(MessageLoop::TYPE_UI);
+  RunTest_PostClosure_SEH(MessageLoop::TYPE_IO);
+}
+
 TEST(MessageLoopTest, PostTask_SEH) {
   RunTest_PostTask_SEH(MessageLoop::TYPE_DEFAULT);
   RunTest_PostTask_SEH(MessageLoop::TYPE_UI);
   RunTest_PostTask_SEH(MessageLoop::TYPE_IO);
 }
 
+TEST(MessageLoopTest, PostDelayedClosure_Basic) {
+  RunTest_PostDelayedTask_Basic(MessageLoop::TYPE_DEFAULT);
+  RunTest_PostDelayedTask_Basic(MessageLoop::TYPE_UI);
+  RunTest_PostDelayedTask_Basic(MessageLoop::TYPE_IO);
+}
+
 TEST(MessageLoopTest, PostDelayedTask_Basic) {
   RunTest_PostDelayedTask_Basic(MessageLoop::TYPE_DEFAULT);
   RunTest_PostDelayedTask_Basic(MessageLoop::TYPE_UI);
   RunTest_PostDelayedTask_Basic(MessageLoop::TYPE_IO);
 }
 
+TEST(MessageLoopTest, PostDelayedClosure_InDelayOrder) {
+  RunTest_PostDelayedClosure_InDelayOrder(MessageLoop::TYPE_DEFAULT);
+  RunTest_PostDelayedClosure_InDelayOrder(MessageLoop::TYPE_UI);
+  RunTest_PostDelayedClosure_InDelayOrder(MessageLoop::TYPE_IO);
+}
+
 TEST(MessageLoopTest, PostDelayedTask_InDelayOrder) {
   RunTest_PostDelayedTask_InDelayOrder(MessageLoop::TYPE_DEFAULT);
   RunTest_PostDelayedTask_InDelayOrder(MessageLoop::TYPE_UI);
   RunTest_PostDelayedTask_InDelayOrder(MessageLoop::TYPE_IO);
 }
 
+TEST(MessageLoopTest, PostDelayedClosure_InPostOrder) {
+  RunTest_PostDelayedClosure_InPostOrder(MessageLoop::TYPE_DEFAULT);
+  RunTest_PostDelayedClosure_InPostOrder(MessageLoop::TYPE_UI);
+  RunTest_PostDelayedClosure_InPostOrder(MessageLoop::TYPE_IO);
+}
+
 TEST(MessageLoopTest, PostDelayedTask_InPostOrder) {
   RunTest_PostDelayedTask_InPostOrder(MessageLoop::TYPE_DEFAULT);
   RunTest_PostDelayedTask_InPostOrder(MessageLoop::TYPE_UI);
   RunTest_PostDelayedTask_InPostOrder(MessageLoop::TYPE_IO);
 }
 
+TEST(MessageLoopTest, PostDelayedClosure_InPostOrder_2) {
+  RunTest_PostDelayedClosure_InPostOrder_2(MessageLoop::TYPE_DEFAULT);
+  RunTest_PostDelayedClosure_InPostOrder_2(MessageLoop::TYPE_UI);
+  RunTest_PostDelayedClosure_InPostOrder_2(MessageLoop::TYPE_IO);
+}
+
 TEST(MessageLoopTest, PostDelayedTask_InPostOrder_2) {
   RunTest_PostDelayedTask_InPostOrder_2(MessageLoop::TYPE_DEFAULT);
   RunTest_PostDelayedTask_InPostOrder_2(MessageLoop::TYPE_UI);
   RunTest_PostDelayedTask_InPostOrder_2(MessageLoop::TYPE_IO);
 }
 
+TEST(MessageLoopTest, PostDelayedClosure_InPostOrder_3) {
+  RunTest_PostDelayedClosure_InPostOrder_3(MessageLoop::TYPE_DEFAULT);
+  RunTest_PostDelayedClosure_InPostOrder_3(MessageLoop::TYPE_UI);
+  RunTest_PostDelayedClosure_InPostOrder_3(MessageLoop::TYPE_IO);
+}
+
 TEST(MessageLoopTest, PostDelayedTask_InPostOrder_3) {
   RunTest_PostDelayedTask_InPostOrder_3(MessageLoop::TYPE_DEFAULT);
   RunTest_PostDelayedTask_InPostOrder_3(MessageLoop::TYPE_UI);
   RunTest_PostDelayedTask_InPostOrder_3(MessageLoop::TYPE_IO);
 }
 
+TEST(MessageLoopTest, PostDelayedClosure_SharedTimer) {
+  RunTest_PostDelayedClosure_SharedTimer(MessageLoop::TYPE_DEFAULT);
+  RunTest_PostDelayedClosure_SharedTimer(MessageLoop::TYPE_UI);
+  RunTest_PostDelayedClosure_SharedTimer(MessageLoop::TYPE_IO);
+}
+
 TEST(MessageLoopTest, PostDelayedTask_SharedTimer) {
   RunTest_PostDelayedTask_SharedTimer(MessageLoop::TYPE_DEFAULT);
   RunTest_PostDelayedTask_SharedTimer(MessageLoop::TYPE_UI);
   RunTest_PostDelayedTask_SharedTimer(MessageLoop::TYPE_IO);
 }
 
 #if defined(OS_WIN)
+TEST(MessageLoopTest, PostDelayedClosure_SharedTimer_SubPump) {
+  RunTest_PostDelayedClosure_SharedTimer_SubPump();
+}
+
 TEST(MessageLoopTest, PostDelayedTask_SharedTimer_SubPump) {
   RunTest_PostDelayedTask_SharedTimer_SubPump();
 }
 #endif
 
 // TODO(darin): MessageLoop does not support deleting all tasks in the
 // destructor.
 // Fails, http://crbug.com/50272.
 TEST(MessageLoopTest, FAILS_EnsureTaskDeletion) {
   RunTest_EnsureTaskDeletion(MessageLoop::TYPE_DEFAULT);
   RunTest_EnsureTaskDeletion(MessageLoop::TYPE_UI);
   RunTest_EnsureTaskDeletion(MessageLoop::TYPE_IO);
 }
 
 // TODO(darin): MessageLoop does not support deleting all tasks in the
 // destructor.
 // Fails, http://crbug.com/50272.
 TEST(MessageLoopTest, FAILS_EnsureTaskDeletion_Chain) {
   RunTest_EnsureTaskDeletion_Chain(MessageLoop::TYPE_DEFAULT);
   RunTest_EnsureTaskDeletion_Chain(MessageLoop::TYPE_UI);
   RunTest_EnsureTaskDeletion_Chain(MessageLoop::TYPE_IO);
 }
 
 #if defined(OS_WIN)
+// TODO(ajwong): Port the Crasher tests Closure.
 TEST(MessageLoopTest, Crasher) {
   RunTest_Crasher(MessageLoop::TYPE_DEFAULT);
   RunTest_Crasher(MessageLoop::TYPE_UI);
   RunTest_Crasher(MessageLoop::TYPE_IO);
 }
 
 TEST(MessageLoopTest, CrasherNasty) {
   RunTest_CrasherNasty(MessageLoop::TYPE_DEFAULT);
   RunTest_CrasherNasty(MessageLoop::TYPE_UI);
   RunTest_CrasherNasty(MessageLoop::TYPE_IO);
 }
 #endif  // defined(OS_WIN)
 
 TEST(MessageLoopTest, Nesting) {
   RunTest_Nesting(MessageLoop::TYPE_DEFAULT);
   RunTest_Nesting(MessageLoop::TYPE_UI);
   RunTest_Nesting(MessageLoop::TYPE_IO);
+  RunTest_NestingClosure(MessageLoop::TYPE_DEFAULT);
+  RunTest_NestingClosure(MessageLoop::TYPE_UI);
+  RunTest_NestingClosure(MessageLoop::TYPE_IO);
 }
 
 TEST(MessageLoopTest, RecursiveDenial1) {
   RunTest_RecursiveDenial1(MessageLoop::TYPE_DEFAULT);
   RunTest_RecursiveDenial1(MessageLoop::TYPE_UI);
   RunTest_RecursiveDenial1(MessageLoop::TYPE_IO);
+  RunTest_RecursiveDenialClosure1(MessageLoop::TYPE_DEFAULT);
+  RunTest_RecursiveDenialClosure1(MessageLoop::TYPE_UI);
+  RunTest_RecursiveDenialClosure1(MessageLoop::TYPE_IO);
 }
 
 TEST(MessageLoopTest, RecursiveSupport1) {
   RunTest_RecursiveSupport1(MessageLoop::TYPE_DEFAULT);
   RunTest_RecursiveSupport1(MessageLoop::TYPE_UI);
   RunTest_RecursiveSupport1(MessageLoop::TYPE_IO);
+  RunTest_RecursiveSupportClosure1(MessageLoop::TYPE_DEFAULT);
+  RunTest_RecursiveSupportClosure1(MessageLoop::TYPE_UI);
+  RunTest_RecursiveSupportClosure1(MessageLoop::TYPE_IO);
 }
 
 #if defined(OS_WIN)
+// TODO(ajwong): Port these.
 // This test occasionally hangs http://crbug.com/44567
 TEST(MessageLoopTest, DISABLED_RecursiveDenial2) {
   RunTest_RecursiveDenial2(MessageLoop::TYPE_DEFAULT);
   RunTest_RecursiveDenial2(MessageLoop::TYPE_UI);
   RunTest_RecursiveDenial2(MessageLoop::TYPE_IO);
 }
 
 TEST(MessageLoopTest, RecursiveSupport2) {
   // This test requires a UI loop
   RunTest_RecursiveSupport2(MessageLoop::TYPE_UI);
 }
 #endif  // defined(OS_WIN)
 
 TEST(MessageLoopTest, NonNestableWithNoNesting) {
   RunTest_NonNestableWithNoNesting(MessageLoop::TYPE_DEFAULT);
   RunTest_NonNestableWithNoNesting(MessageLoop::TYPE_UI);
   RunTest_NonNestableWithNoNesting(MessageLoop::TYPE_IO);
+  RunTest_NonNestableClosureWithNoNesting(MessageLoop::TYPE_DEFAULT);
+  RunTest_NonNestableClosureWithNoNesting(MessageLoop::TYPE_UI);
+  RunTest_NonNestableClosureWithNoNesting(MessageLoop::TYPE_IO);
 }
 
 TEST(MessageLoopTest, NonNestableInNestedLoop) {
   RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_DEFAULT, false);
   RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_UI, false);
   RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_IO, false);
+  RunTest_NonNestableClosureInNestedLoop(MessageLoop::TYPE_DEFAULT, false);
+  RunTest_NonNestableClosureInNestedLoop(MessageLoop::TYPE_UI, false);
+  RunTest_NonNestableClosureInNestedLoop(MessageLoop::TYPE_IO, false);
 }
 
 TEST(MessageLoopTest, NonNestableDelayedInNestedLoop) {
   RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_DEFAULT, true);
   RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_UI, true);
   RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_IO, true);
+  RunTest_NonNestableClosureInNestedLoop(MessageLoop::TYPE_DEFAULT, true);
+  RunTest_NonNestableClosureInNestedLoop(MessageLoop::TYPE_UI, true);
+  RunTest_NonNestableClosureInNestedLoop(MessageLoop::TYPE_IO, true);
 }
 
 class DummyTask : public Task {
  public:
   explicit DummyTask(int num_tasks) : num_tasks_(num_tasks) {}
 
   virtual void Run() {
     if (num_tasks_ > 1) {
       MessageLoop::current()->PostTask(
           FROM_HERE,
@@ skipping 232 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);
 }