Adds the ability for ObserverList to not notify observers added during...

base/observer_list_unittest.cc

 // Copyright (c) 2006-2008 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/message_loop.h"
 #include "base/observer_list.h"
 #include "base/observer_list_threadsafe.h"
 #include "base/platform_thread.h"
 #include "base/ref_counted.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 42 matching lines @@
       : list_(list), doomed_(doomed) { }
   virtual ~ThreadSafeDisrupter() { }
   virtual void Observe(int x) {
     list_->RemoveObserver(doomed_);
   }
  private:
   ObserverListThreadSafe<Foo>* list_;
   Foo* doomed_;
 };
 
+class AddInObserve : public Foo {
+ public:
+  AddInObserve(ObserverList<Foo>* 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;
+  Adder adder;
+};
+
+
 class ObserverListThreadSafeTest : public testing::Test {
 };
 
 static const int kThreadRunTime = 10000;  // 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 {
@@ skipping 182 matching lines @@
   // Use 7 observer threads.  Notifications only come from
   // 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(ObserverListTest, Existing) {
+  ObserverList<Foo> observer_list(ObserverList<Foo>::NOTIFY_EXISTING_ONLY);
+  Adder a(1);
+  AddInObserve 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);
+}