Use MessageLoopProxy instead of MessageLoop to dispatch notifications in ObserverListThreadsafe.

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 43 matching lines @@
       : list_(list), doomed_(doomed) { }
   virtual ~ThreadSafeDisrupter() { }
   virtual void Observe(int x) {
     list_->RemoveObserver(doomed_);
   }
  private:
   ObserverListThreadSafe<Foo>* list_;
   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) {
   }
   virtual void Observe(int x) {
     if (!added) {
       added = true;
       observer_list->AddObserver(&adder);
     }
   }
 
   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
 // which will add and remove itself from the notification
 // list repeatedly.
 class AddRemoveThread : public PlatformThread::Delegate,
                         public Foo {
  public:
   AddRemoveThread(ObserverListThreadSafe<Foo>* list, bool notify)
       : list_(list),
@@ skipping 253 matching lines @@
   // the main thread.
   ThreadSafeObserverHarness(7, false);
 }
 
 TEST(ObserverListThreadSafeTest, CrossThreadNotifications) {
   // Use 3 observer threads.  Notifications will fire from
   // the main thread and all 3 observer threads.
   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);
 
   FOR_EACH_OBSERVER(Foo, observer_list, Observe(1));
 
   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.
   FOR_EACH_OBSERVER(Foo, observer_list, Observe(1));
   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)
       : list_(list), added_(false), adder_(1) {}
 
   virtual void Observe(int /* x */) {
     list_->Clear();
     list_->AddObserver(&adder_);
     added_ = true;
   }
@@ skipping 49 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