Make base::MessageLoops have names at construction time

base/message_loop_unittest.cc

Index: base/message_loop_unittest.cc
diff --git a/base/message_loop_unittest.cc b/base/message_loop_unittest.cc
index 092f58a6365b60aa7ea3a6c7103ec730661c113b..0a91608b2a175ed26c7ce2e8be00423b5939cda9 100644
--- a/base/message_loop_unittest.cc
+++ b/base/message_loop_unittest.cc
@@ -84,7 +84,7 @@ class Foo : public base::RefCounted<Foo> {
 // TODO(ajwong): Remove this once we've finished getting rid of the PostTask()
 // compatibility methods.
 void RunTest_PostLegacyTask(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   // Add tests to message loop
   scoped_refptr<Foo> foo(new Foo());
@@ -114,7 +114,7 @@ void RunTest_PostLegacyTask(MessageLoop::Type message_loop_type) {
 }
 
 void RunTest_PostTask(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   // Add tests to message loop
   scoped_refptr<Foo> foo(new Foo());
@@ -144,7 +144,7 @@ void RunTest_PostTask(MessageLoop::Type message_loop_type) {
 }
 
 void RunTest_PostTask_SEH(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   // Add tests to message loop
   scoped_refptr<Foo> foo(new Foo());
@@ -194,7 +194,7 @@ static void RecordRunTimeFunc(Time* run_time, int* quit_counter) {
 }
 
 void RunTest_PostDelayedTask_Basic(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   // Test that PostDelayedTask results in a delayed task.
 
@@ -217,7 +217,7 @@ void RunTest_PostDelayedTask_Basic(MessageLoop::Type message_loop_type) {
 
 void RunTest_PostDelayedTask_InDelayOrder(
     MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   // Test that two tasks with different delays run in the right order.
   int num_tasks = 2;
@@ -238,7 +238,7 @@ void RunTest_PostDelayedTask_InDelayOrder(
 
 void RunTest_PostDelayedTask_InPostOrder(
     MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   // Test that two tasks with the same delay run in the order in which they
   // were posted.
@@ -268,7 +268,7 @@ void RunTest_PostDelayedTask_InPostOrder(
 
 void RunTest_PostDelayedTask_InPostOrder_2(
     MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", 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.
@@ -293,7 +293,7 @@ void RunTest_PostDelayedTask_InPostOrder_2(
 
 void RunTest_PostDelayedTask_InPostOrder_3(
     MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", 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
@@ -320,7 +320,7 @@ void RunTest_PostDelayedTask_InPostOrder_3(
 
 void RunTest_PostDelayedTask_SharedTimer(
     MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", 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.
@@ -369,7 +369,7 @@ void SubPumpFunc() {
 }
 
 void RunTest_PostDelayedTask_SharedTimer_SubPump() {
-  MessageLoop loop(MessageLoop::TYPE_UI);
+  MessageLoop loop("MessageLoopTest", 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.
@@ -435,7 +435,7 @@ void RunTest_EnsureDeletion(MessageLoop::Type message_loop_type) {
   bool a_was_deleted = false;
   bool b_was_deleted = false;
   {
-    MessageLoop loop(message_loop_type);
+    MessageLoop loop("MessageLoopTest", message_loop_type);
     loop.PostTask(
         FROM_HERE, base::Bind(&RecordDeletionProbe::Run,
                               new RecordDeletionProbe(NULL, &a_was_deleted)));
@@ -453,7 +453,7 @@ void RunTest_EnsureDeletion_Chain(MessageLoop::Type message_loop_type) {
   bool b_was_deleted = false;
   bool c_was_deleted = false;
   {
-    MessageLoop loop(message_loop_type);
+    MessageLoop loop("MessageLoopTest", message_loop_type);
     // The scoped_refptr for each of the below is held either by the chained
     // RecordDeletionProbe, or the bound RecordDeletionProbe::Run() callback.
     RecordDeletionProbe* a = new RecordDeletionProbe(NULL, &a_was_deleted);
@@ -557,7 +557,7 @@ LONG WINAPI HandleCrasherException(EXCEPTION_POINTERS *ex_info) {
 }
 
 void RunTest_Crasher(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   if (::IsDebuggerPresent())
     return;
@@ -576,7 +576,7 @@ void RunTest_Crasher(MessageLoop::Type message_loop_type) {
 }
 
 void RunTest_CrasherNasty(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   if (::IsDebuggerPresent())
     return;
@@ -597,7 +597,7 @@ void RunTest_CrasherNasty(MessageLoop::Type message_loop_type) {
 #endif  // defined(OS_WIN)
 
 void RunTest_Nesting(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   int depth = 100;
   MessageLoop::current()->PostTask(FROM_HERE,
@@ -800,7 +800,7 @@ void RecursiveFuncWin(MessageLoop* target,
 #endif  // defined(OS_WIN)
 
 void RunTest_RecursiveDenial1(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   EXPECT_TRUE(MessageLoop::current()->NestableTasksAllowed());
   TaskList order;
@@ -835,7 +835,7 @@ void RunTest_RecursiveDenial1(MessageLoop::Type message_loop_type) {
 }
 
 void RunTest_RecursiveDenial3(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   EXPECT_TRUE(MessageLoop::current()->NestableTasksAllowed());
   TaskList order;
@@ -871,7 +871,7 @@ void RunTest_RecursiveDenial3(MessageLoop::Type message_loop_type) {
 }
 
 void RunTest_RecursiveSupport1(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   TaskList order;
   MessageLoop::current()->PostTask(
@@ -907,7 +907,7 @@ void RunTest_RecursiveSupport1(MessageLoop::Type message_loop_type) {
 
 // A side effect of this test is the generation a beep. Sorry.
 void RunTest_RecursiveDenial2(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   Thread worker("RecursiveDenial2_worker");
   Thread::Options options;
@@ -951,7 +951,7 @@ void RunTest_RecursiveDenial2(MessageLoop::Type message_loop_type) {
 // A side effect of this test is the generation a beep. Sorry.  This test also
 // needs to process windows messages on the current thread.
 void RunTest_RecursiveSupport2(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   Thread worker("RecursiveSupport2_worker");
   Thread::Options options;
@@ -1011,7 +1011,7 @@ void FuncThatPumps(TaskList* order, int cookie) {
 // 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);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   TaskList order;
 
@@ -1037,7 +1037,7 @@ void RunTest_NonNestableWithNoNesting(
 // 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);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   TaskList order;
 
@@ -1115,7 +1115,7 @@ void MouseDownUp() {
 }
 
 void RunTest_Dispatcher(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                           base::Bind(&MouseDownUp), 100);
@@ -1134,7 +1134,7 @@ LRESULT CALLBACK MsgFilterProc(int code, WPARAM wparam, LPARAM lparam) {
 }
 
 void RunTest_DispatcherWithMessageHook(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                           base::Bind(&MouseDownUp), 100);
@@ -1491,7 +1491,7 @@ TEST(MessageLoopTest, TaskObserver) {
   const int kNumPosts = 6;
   DummyTaskObserver observer(kNumPosts);
 
-  MessageLoop loop;
+  MessageLoop loop("MessageLoopTest");
   loop.AddTaskObserver(&observer);
   loop.PostTask(FROM_HERE, base::Bind(&PostNTasksThenQuit, kNumPosts));
   loop.Run();
@@ -1521,7 +1521,7 @@ TEST(MessageLoopTest, WaitForIO) {
 }
 
 TEST(MessageLoopTest, HighResolutionTimer) {
-  MessageLoop loop;
+  MessageLoop loop("MessageLoopTest");
 
   const int kFastTimerMs = 5;
   const int kSlowTimerMs = 100;
@@ -1582,7 +1582,7 @@ TEST(MessageLoopTest, FileDescriptorWatcherOutlivesMessageLoop) {
     // Arrange for controller to live longer than message loop.
     MessageLoopForIO::FileDescriptorWatcher controller;
     {
-      MessageLoopForIO message_loop;
+      MessageLoopForIO message_loop("MessageLoopTest");
 
       QuitDelegate delegate;
       message_loop.WatchFileDescriptor(fd,
@@ -1605,7 +1605,7 @@ TEST(MessageLoopTest, FileDescriptorWatcherDoubleStop) {
   int fd = pipefds[1];
   {
     // Arrange for message loop to live longer than controller.
-    MessageLoopForIO message_loop;
+    MessageLoopForIO message_loop("MessageLoopTest");
     {
       MessageLoopForIO::FileDescriptorWatcher controller;
 
@@ -1675,7 +1675,7 @@ class MLDestructionObserver : public MessageLoop::DestructionObserver {
 TEST(MessageLoopTest, DestructionObserverTest) {
   // Verify that the destruction observer gets called at the very end (after
   // all the pending tasks have been destroyed).
-  MessageLoop* loop = new MessageLoop;
+  MessageLoop* loop = new MessageLoop("MessageLoopTest");
   const int kDelayMS = 100;
 
   bool task_destroyed = false;