Make ObserverListThreadSafe key its observers by PlatformThreadId instead of MessageLoop.

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/compiler_specific.h"
@@ skipping 240 matching lines @@
   // Should also do nothing.
   observer_list->RemoveObserver(&b);
 
   observer_list->Notify(&Foo::Observe, 10);
   loop.RunAllPending();
 
   EXPECT_EQ(a.total, 10);
   EXPECT_EQ(b.total, 0);
 }
 
+TEST(ObserverListThreadSafeTest, WithoutMessageLoop) {
+  scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
+      new ObserverListThreadSafe<Foo>);
+
+  Adder a(1), b(1), c(1);
+
+  // No MessageLoop, so these should not be added.
+  observer_list->AddObserver(&a);
+  observer_list->AddObserver(&b);
+
+  {
+    // Add c when there's a loop.
+    MessageLoop loop;
+    observer_list->AddObserver(&c);
+
+    observer_list->Notify(&Foo::Observe, 10);
+    loop.RunAllPending();
+
+    EXPECT_EQ(0, a.total);
+    EXPECT_EQ(0, b.total);
+    EXPECT_EQ(10, c.total);
+
+    // Now add a when there's a loop.
+    observer_list->AddObserver(&a);
+
+    // Remove c when there's a loop.
+    observer_list->RemoveObserver(&c);
+
+    // Notify again.
+    observer_list->Notify(&Foo::Observe, 20);
+    loop.RunAllPending();
+
+    EXPECT_EQ(20, a.total);
+    EXPECT_EQ(0, b.total);
+    EXPECT_EQ(10, c.total);
+  }
+
+  // Removing should always succeed with or without a loop.
+  observer_list->RemoveObserver(&a);
+
+  // Notifying should not fail but should also be a no-op.
+  MessageLoop loop;
+  observer_list->AddObserver(&b);
+  observer_list->Notify(&Foo::Observe, 30);
+  loop.RunAllPending();
+
+  EXPECT_EQ(20, a.total);
+  EXPECT_EQ(30, b.total);
+  EXPECT_EQ(10, c.total);
+}
+
 class FooRemover : public Foo {
  public:
   explicit FooRemover(ObserverListThreadSafe<Foo>* list) : list_(list) {}
   virtual ~FooRemover() {}
 
   void AddFooToRemove(Foo* foo) {
     foos_.push_back(foo);
   }
 
   virtual void Observe(int x) {
@@ skipping 205 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