Make base::MessageLoops have names at construction time

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/compiler_specific.h"
 #include "base/eintr_wrapper.h"
@@ skipping 66 matching lines @@
 
   ~Foo() {}
 
   int test_count_;
   std::string result_;
 };
 
 // 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());
   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));
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       foo.get(), &Foo::Test1Ptr, &b));
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       foo.get(), &Foo::Test1Int, 100));
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
       foo.get(), &Foo::Test2Ptr, &a, &c));
   MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
     foo.get(), &Foo::Test2Mixed, a, &d));
 
   // After all tests, post a message that will shut down the message loop
   MessageLoop::current()->PostTask(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);
+  MessageLoop loop("MessageLoopTest", 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, base::Bind(
       &Foo::Test0, foo.get()));
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
     &Foo::Test1ConstRef, foo.get(), a));
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &Foo::Test1Ptr, foo.get(), &b));
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &Foo::Test1Int, foo.get(), 100));
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &Foo::Test2Ptr, foo.get(), &a, &c));
   MessageLoop::current()->PostTask(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()->PostTask(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_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());
   std::string a("a"), b("b"), c("c"), d("d");
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &Foo::Test0, foo.get()));
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &Foo::Test1ConstRef, foo.get(), a));
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
       &Foo::Test1Ptr, foo.get(), &b));
@@ skipping 29 matching lines @@
 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);
 }
 
 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.
 
   const int kDelayMS = 100;
 
   int num_tasks = 1;
   Time run_time;
 
   loop.PostDelayedTask(
       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_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;
   Time run_time1, run_time2;
 
   loop.PostDelayedTask(
       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.PostDelayedTask(
       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_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.
   //
   // 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,
       base::Bind(&RecordRunTimeFunc, &run_time1, &num_tasks), kDelayMS);
   loop.PostDelayedTask(
       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_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.
 
   const int kPauseMS = 50;
 
   int num_tasks = 2;
   Time run_time;
 
   loop.PostTask(FROM_HERE, base::Bind(&SlowFunc, kPauseMS, &num_tasks));
   loop.PostDelayedTask(
       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_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
   // 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,
                   base::Bind(&RecordRunTimeFunc, &run_time1, &num_tasks));
 
   loop.PostDelayedTask(
       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_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.
 
   // 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.PostDelayedTask(
@@ skipping 28 matching lines @@
   MessageLoop::current()->SetNestableTasksAllowed(true);
   MSG msg;
   while (GetMessage(&msg, NULL, 0, 0)) {
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
   MessageLoop::current()->Quit();
 }
 
 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.
 
   // 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.PostTask(FROM_HERE, base::Bind(&SubPumpFunc));
@@ skipping 45 matching lines @@
   void Run() {}
  private:
   scoped_refptr<RecordDeletionProbe> post_on_delete_;
   bool* was_deleted_;
 };
 
 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)));
     loop.PostDelayedTask(
         FROM_HERE, base::Bind(&RecordDeletionProbe::Run,
                               new RecordDeletionProbe(NULL, &b_was_deleted)),
         1000);  // TODO(ajwong): Do we really need 1000ms here?
   }
   EXPECT_TRUE(a_was_deleted);
   EXPECT_TRUE(b_was_deleted);
 }
 
 void RunTest_EnsureDeletion_Chain(MessageLoop::Type message_loop_type) {
   bool a_was_deleted = false;
   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);
     RecordDeletionProbe* b = new RecordDeletionProbe(a, &b_was_deleted);
     RecordDeletionProbe* c = new RecordDeletionProbe(b, &c_was_deleted);
     loop.PostTask(FROM_HERE, base::Bind(&RecordDeletionProbe::Run, c));
   }
   EXPECT_TRUE(a_was_deleted);
   EXPECT_TRUE(b_was_deleted);
   EXPECT_TRUE(c_was_deleted);
@@ skipping 83 matching lines @@
 #elif defined(_M_X64)
 
   ex_info->ContextRecord->Rip -= 5;
 
 #endif
 
   return EXCEPTION_CONTINUE_EXECUTION;
 }
 
 void RunTest_Crasher(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   if (::IsDebuggerPresent())
     return;
 
   LPTOP_LEVEL_EXCEPTION_FILTER old_SEH_filter =
       ::SetUnhandledExceptionFilter(&HandleCrasherException);
 
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&Crasher::Run, new Crasher(false)));
   MessageLoop::current()->set_exception_restoration(true);
   MessageLoop::current()->Run();
   MessageLoop::current()->set_exception_restoration(false);
 
   ::SetUnhandledExceptionFilter(old_SEH_filter);
 }
 
 void RunTest_CrasherNasty(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   if (::IsDebuggerPresent())
     return;
 
   LPTOP_LEVEL_EXCEPTION_FILTER old_SEH_filter =
       ::SetUnhandledExceptionFilter(&HandleCrasherException);
 
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&Crasher::Run, new Crasher(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_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,
                                    base::Bind(&NestingFunc, &depth));
   MessageLoop::current()->Run();
   EXPECT_EQ(depth, 0);
 }
 
 const wchar_t* const kMessageBoxTitle = L"MessageLoop Unit Test";
 
@@ skipping 182 matching lines @@
         }
       }
       break;
     }
   }
 }
 
 #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;
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&RecursiveFunc, &order, 1, 2, false));
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&RecursiveFunc, &order, 2, 2, false));
   MessageLoop::current()->PostTask(
@@ skipping 14 matching lines @@
   EXPECT_EQ(order.Get(7), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 2, false));
 }
 
 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;
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&RecursiveSlowFunc, &order, 1, 2, false));
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&RecursiveSlowFunc, &order, 2, 2, false));
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE, base::Bind(&OrderedFunc, &order, 3), 5);
   MessageLoop::current()->PostDelayedTask(
@@ skipping 15 matching lines @@
   EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order.Get(10), TaskItem(QUITMESSAGELOOP, 4, true));
   EXPECT_EQ(order.Get(11), TaskItem(QUITMESSAGELOOP, 4, false));
   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(14), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(15), TaskItem(RECURSIVE, 2, false));
 }
 
 void RunTest_RecursiveSupport1(MessageLoop::Type message_loop_type) {
-  MessageLoop loop(message_loop_type);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   TaskList order;
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&RecursiveFunc, &order, 1, 2, true));
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&RecursiveFunc, &order, 2, 2, true));
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&QuitFunc, &order, 3));
 
   MessageLoop::current()->Run();
@@ skipping 15 matching lines @@
   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 2, false));
 }
 
 #if defined(OS_WIN)
 // TODO(darin): These tests need to be ported since they test critical
 // message loop functionality.
 
 // 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;
   options.message_loop_type = message_loop_type;
   ASSERT_EQ(true, worker.StartWithOptions(options));
   TaskList order;
   base::win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
   worker.message_loop()->PostTask(FROM_HERE,
                                   base::Bind(&RecursiveFuncWin,
                                              MessageLoop::current(),
@@ skipping 23 matching lines @@
   EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 3, false));
   EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(14), TaskItem(RECURSIVE, 1, false));
   EXPECT_EQ(order.Get(15), TaskItem(RECURSIVE, 3, true));
   EXPECT_EQ(order.Get(16), TaskItem(RECURSIVE, 3, false));
 }
 
 // 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;
   options.message_loop_type = message_loop_type;
   ASSERT_EQ(true, worker.StartWithOptions(options));
   TaskList order;
   base::win::ScopedHandle event(CreateEvent(NULL, FALSE, FALSE, NULL));
   worker.message_loop()->PostTask(FROM_HERE,
                                   base::Bind(&RecursiveFuncWin,
                                              MessageLoop::current(),
@@ skipping 39 matching lines @@
   bool old_state = MessageLoop::current()->NestableTasksAllowed();
   MessageLoop::current()->SetNestableTasksAllowed(true);
   MessageLoop::current()->RunAllPending();
   MessageLoop::current()->SetNestableTasksAllowed(old_state);
   order->RecordEnd(PUMPS, 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;
 
   MessageLoop::current()->PostNonNestableTask(
       FROM_HERE,
       base::Bind(&OrderedFunc, &order, 1));
   MessageLoop::current()->PostTask(FROM_HERE,
                                    base::Bind(&OrderedFunc, &order, 2));
   MessageLoop::current()->PostTask(FROM_HERE,
                                    base::Bind(&QuitFunc, &order, 3));
   MessageLoop::current()->Run();
 
   // FIFO order.
   ASSERT_EQ(6U, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(ORDERERD, 1, true));
   EXPECT_EQ(order.Get(1), TaskItem(ORDERERD, 1, false));
   EXPECT_EQ(order.Get(2), TaskItem(ORDERERD, 2, true));
   EXPECT_EQ(order.Get(3), TaskItem(ORDERERD, 2, false));
   EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
   EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, 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);
+  MessageLoop loop("MessageLoopTest", message_loop_type);
 
   TaskList order;
 
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&FuncThatPumps, &order, 1));
   if (use_delayed) {
     MessageLoop::current()->PostNonNestableDelayedTask(
         FROM_HERE,
         base::Bind(&OrderedFunc, &order, 2),
@@ skipping 57 matching lines @@
 
   int dispatch_count_;
 };
 
 void MouseDownUp() {
   PostMessage(NULL, WM_LBUTTONDOWN, 0, 0);
   PostMessage(NULL, WM_LBUTTONUP, 'A', 0);
 }
 
 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);
   DispatcherImpl dispatcher;
   MessageLoopForUI::current()->Run(&dispatcher);
   ASSERT_EQ(2, dispatcher.dispatch_count_);
 }
 
 LRESULT CALLBACK MsgFilterProc(int code, WPARAM wparam, LPARAM lparam) {
   if (code == base::MessagePumpForUI::kMessageFilterCode) {
     MSG* msg = reinterpret_cast<MSG*>(lparam);
     if (msg->message == WM_LBUTTONDOWN)
       return TRUE;
   }
   return FALSE;
 }
 
 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);
   HHOOK msg_hook = SetWindowsHookEx(WH_MSGFILTER,
                                     MsgFilterProc,
                                     NULL,
                                     GetCurrentThreadId());
   DispatcherImpl dispatcher;
   MessageLoopForUI::current()->Run(&dispatcher);
   ASSERT_EQ(1, dispatcher.dispatch_count_);
@@ skipping 336 matching lines @@
   int num_tasks_processed_;
   const int num_tasks_;
 
   DISALLOW_COPY_AND_ASSIGN(DummyTaskObserver);
 };
 
 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();
   loop.RemoveTaskObserver(&observer);
 
   EXPECT_EQ(kNumPosts, observer.num_tasks_started());
   EXPECT_EQ(kNumPosts, observer.num_tasks_processed());
 }
 
 #if defined(OS_WIN)
 TEST(MessageLoopTest, Dispatcher) {
   // This test requires a UI loop
   RunTest_Dispatcher(MessageLoop::TYPE_UI);
 }
 
 TEST(MessageLoopTest, DispatcherWithMessageHook) {
   // This test requires a UI loop
   RunTest_DispatcherWithMessageHook(MessageLoop::TYPE_UI);
 }
 
 TEST(MessageLoopTest, IOHandler) {
   RunTest_IOHandler();
 }
 
 TEST(MessageLoopTest, WaitForIO) {
   RunTest_WaitForIO();
 }
 
 TEST(MessageLoopTest, HighResolutionTimer) {
-  MessageLoop loop;
+  MessageLoop loop("MessageLoopTest");
 
   const int kFastTimerMs = 5;
   const int kSlowTimerMs = 100;
 
   EXPECT_FALSE(loop.high_resolution_timers_enabled());
 
   // Post a fast task to enable the high resolution timers.
   loop.PostDelayedTask(FROM_HERE, base::Bind(&PostNTasksThenQuit, 1),
                        kFastTimerMs);
   loop.Run();
@@ skipping 40 matching lines @@
   // as we don't need to actually get any notifications.
   // pipe() is just the easiest way to do it.
   int pipefds[2];
   int err = pipe(pipefds);
   ASSERT_EQ(0, err);
   int fd = pipefds[1];
   {
     // 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,
           true, MessageLoopForIO::WATCH_WRITE, &controller, &delegate);
       // and don't run the message loop, just destroy it.
     }
   }
   if (HANDLE_EINTR(close(pipefds[0])) < 0)
     PLOG(ERROR) << "close";
   if (HANDLE_EINTR(close(pipefds[1])) < 0)
     PLOG(ERROR) << "close";
 }
 
 TEST(MessageLoopTest, FileDescriptorWatcherDoubleStop) {
   // Verify that it's ok to call StopWatchingFileDescriptor().
   // (Errors only showed up in valgrind.)
   int pipefds[2];
   int err = pipe(pipefds);
   ASSERT_EQ(0, err);
   int fd = pipefds[1];
   {
     // Arrange for message loop to live longer than controller.
-    MessageLoopForIO message_loop;
+    MessageLoopForIO message_loop("MessageLoopTest");
     {
       MessageLoopForIO::FileDescriptorWatcher controller;
 
       QuitDelegate delegate;
       message_loop.WatchFileDescriptor(fd,
           true, MessageLoopForIO::WATCH_WRITE, &controller, &delegate);
       controller.StopWatchingFileDescriptor();
     }
   }
   if (HANDLE_EINTR(close(pipefds[0])) < 0)
@@ skipping 49 matching lines @@
   bool* task_destroyed_;
   bool* destruction_observer_called_;
   bool task_destroyed_before_message_loop_;
 };
 
 }  // namespace
 
 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;
   bool destruction_observer_called = false;
 
   MLDestructionObserver observer(&task_destroyed, &destruction_observer_called);
   loop->AddDestructionObserver(&observer);
   loop->PostDelayedTask(
       FROM_HERE,
       base::Bind(&DestructionObserverProbe::Run,
                  new DestructionObserverProbe(&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);
 }