Use MessageLoopProxy instead of MessageLoop to dispatch notifications in ObserverListThreadsafe.

This is nearly identical to the reverted r96013, with the modification that
std::map::insert isn't used.  Its invocation was complex (such that
it worked in some compilers but not in others) and the performance gain is
negligible in any use case I've seen in Chromium.

BUG=91589

Review URL: http://codereview.chromium.org/7604006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@96076 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 41 insertions, 6 deletions

diff --git a/base/observer_list_unittest.cc b/base/observer_list_unittest.cc
index d0d2001..9e8edf6 100644
--- a/base/observer_list_unittest.cc
+++ b/base/observer_list_unittest.cc
@@ -61,9 +61,10 @@ class ThreadSafeDisrupter : public Foo {
   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 @@ class AddInObserve : public Foo {
   }
 
   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 @@ TEST(ObserverListThreadSafeTest, CrossThreadNotifications) {
   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 @@ TEST(ObserverListTest, Existing) {
   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)