Make base::MessageLoops have names at construction time

base/observer_list_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 "base/observer_list.h"
 #include "base/observer_list_threadsafe.h"
 
 #include <vector>
 
 #include "base/memory/ref_counted.h"
@@ skipping 89 matching lines @@
         count_addtask_(0),
         do_notifies_(notify) {
     factory_ = new ScopedRunnableMethodFactory<AddRemoveThread>(this);
   }
 
   virtual ~AddRemoveThread() {
     delete factory_;
   }
 
   void ThreadMain() {
-    loop_ = new MessageLoop();  // Fire up a message loop.
+    loop_ = new MessageLoop("ThreadMain");  // Fire up a message loop.
     loop_->PostTask(
         FROM_HERE, factory_->NewRunnableMethod(&AddRemoveThread::AddTask));
     loop_->Run();
     //LOG(ERROR) << "Loop 0x" << std::hex << loop_ << " done. " <<
     //    count_observes_ << ", " << count_addtask_;
     delete loop_;
     loop_ = reinterpret_cast<MessageLoop*>(0xdeadbeef);
     delete this;
   }
 
@@ skipping 72 matching lines @@
   FOR_EACH_OBSERVER(Foo, observer_list, Observe(10));
 
   EXPECT_EQ(a.total, 20);
   EXPECT_EQ(b.total, -20);
   EXPECT_EQ(c.total, 0);
   EXPECT_EQ(d.total, -10);
   EXPECT_EQ(e.total, 0);
 }
 
 TEST(ObserverListThreadSafeTest, BasicTest) {
-  MessageLoop loop;
+  MessageLoop loop("ObserverListThreadSafeTest");
 
   scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
       new ObserverListThreadSafe<Foo>);
   Adder a(1);
   Adder b(-1);
   Adder c(1);
   Adder d(-1);
   ThreadSafeDisrupter evil(observer_list.get(), &c);
 
   observer_list->AddObserver(&a);
   observer_list->AddObserver(&b);
 
   observer_list->Notify(&Foo::Observe, 10);
   loop.RunAllPending();
 
   observer_list->AddObserver(&evil);
   observer_list->AddObserver(&c);
   observer_list->AddObserver(&d);
 
   observer_list->Notify(&Foo::Observe, 10);
   loop.RunAllPending();
 
   EXPECT_EQ(a.total, 20);
   EXPECT_EQ(b.total, -20);
   EXPECT_EQ(c.total, 0);
   EXPECT_EQ(d.total, -10);
 }
 
 TEST(ObserverListThreadSafeTest, RemoveObserver) {
-  MessageLoop loop;
+  MessageLoop loop("ObserverListThreadSafeTest");
 
   scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
       new ObserverListThreadSafe<Foo>);
   Adder a(1), b(1);
 
   // Should do nothing.
   observer_list->RemoveObserver(&a);
   observer_list->RemoveObserver(&b);
 
   observer_list->Notify(&Foo::Observe, 10);
@@ skipping 31 matching lines @@
       list_->RemoveObserver(*it);
     }
   }
 
  private:
   const scoped_refptr<ObserverListThreadSafe<Foo> > list_;
   std::vector<Foo*> foos_;
 };
 
 TEST(ObserverListThreadSafeTest, RemoveMultipleObservers) {
-  MessageLoop loop;
+  MessageLoop loop("ObserverListThreadSafeTest");
   scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
       new ObserverListThreadSafe<Foo>);
 
   FooRemover a(observer_list);
   Adder b(1);
 
   observer_list->AddObserver(&a);
   observer_list->AddObserver(&b);
 
   a.AddFooToRemove(&a);
   a.AddFooToRemove(&b);
 
   observer_list->Notify(&Foo::Observe, 1);
   loop.RunAllPending();
 }
 
 // A test driver for a multi-threaded notification loop.  Runs a number
 // of observer threads, each of which constantly adds/removes itself
 // from the observer list.  Optionally, if cross_thread_notifies is set
 // to true, the observer threads will also trigger notifications to
 // all observers.
 static void ThreadSafeObserverHarness(int num_threads,
                                       bool cross_thread_notifies) {
-  MessageLoop loop;
+  MessageLoop loop("ThreadSafeObserverHarness");
 
   const int kMaxThreads = 15;
   num_threads = num_threads > kMaxThreads ? kMaxThreads : num_threads;
 
   scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
       new ObserverListThreadSafe<Foo>);
   Adder a(1);
   Adder b(-1);
   Adder c(1);
   Adder d(-1);
@@ skipping 119 matching lines @@
   ObserverList<Foo>* observer_list = new ObserverList<Foo>;
   ListDestructor a(observer_list);
   observer_list->AddObserver(&a);
 
   FOR_EACH_OBSERVER(Foo, *observer_list, Observe(0));
   // If this test fails, there'll be Valgrind errors when this function goes out
   // of scope.
 }
 
 }  // namespace