Merge 96076 - Use MessageLoopProxy instead of MessageLoop to dispatch notifications in ObserverLi...

base/observer_list_unittest.cc

Index: base/observer_list_unittest.cc
===================================================================
--- base/observer_list_unittest.cc	(revision 98840)
+++ base/observer_list_unittest.cc	(working copy)
@@ -61,9 +61,10 @@
   Foo* doomed_;
 };
 
+template <typename ObserverListType>
 class AddInObserve : public Foo {
  public:
-  explicit AddInObserve(ObserverList<Foo>* observer_list)
+  explicit AddInObserve(ObserverListType* observer_list)
       : added(false),
         observer_list(observer_list),
         adder(1) {
@@ -76,14 +77,11 @@
   }
 
   bool added;
-  ObserverList<Foo>* observer_list;
+  ObserverListType* observer_list;
   Adder adder;
 };
 
 
-class ObserverListThreadSafeTest : public testing::Test {
-};
-
 static const int kThreadRunTime = 2000;  // ms to run the multi-threaded test.
 
 // A thread for use in the ThreadSafeObserver test
@@ -357,10 +355,22 @@
   ThreadSafeObserverHarness(3, true);
 }
 
+TEST(ObserverListThreadSafeTest, OutlivesMessageLoop) {
+  MessageLoop* loop = new MessageLoop;
+  scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
+      new ObserverListThreadSafe<Foo>);
+
+  Adder a(1);
+  observer_list->AddObserver(&a);
+  delete loop;
+  // Test passes if we don't crash here.
+  observer_list->Notify(&Foo::Observe, 1);
+}
+
 TEST(ObserverListTest, Existing) {
   ObserverList<Foo> observer_list(ObserverList<Foo>::NOTIFY_EXISTING_ONLY);
   Adder a(1);
-  AddInObserve b(&observer_list);
+  AddInObserve<ObserverList<Foo> > b(&observer_list);
 
   observer_list.AddObserver(&a);
   observer_list.AddObserver(&b);
@@ -377,6 +387,31 @@
   EXPECT_EQ(1, b.adder.total);
 }
 
+// Same as above, but for ObserverListThreadSafe
+TEST(ObserverListThreadSafeTest, Existing) {
+  MessageLoop loop;
+  scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
+      new ObserverListThreadSafe<Foo>(ObserverList<Foo>::NOTIFY_EXISTING_ONLY));
+  Adder a(1);
+  AddInObserve<ObserverListThreadSafe<Foo> > b(observer_list.get());
+
+  observer_list->AddObserver(&a);
+  observer_list->AddObserver(&b);
+
+  observer_list->Notify(&Foo::Observe, 1);
+  loop.RunAllPending();
+
+  EXPECT_TRUE(b.added);
+  // B's adder should not have been notified because it was added during
+  // notificaiton.
+  EXPECT_EQ(0, b.adder.total);
+
+  // Notify again to make sure b's adder is notified.
+  observer_list->Notify(&Foo::Observe, 1);
+  loop.RunAllPending();
+  EXPECT_EQ(1, b.adder.total);
+}
+
 class AddInClearObserve : public Foo {
  public:
   explicit AddInClearObserve(ObserverList<Foo>* list)