Pass FROM_HERE to ObserverListThreadSafe::Notify to improve profile.

base/observer_list_unittest.cc

 // Copyright (c) 2012 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 116 matching lines @@
       VLOG(1) << "DONE!";
       return;
     }
 
     if (!in_list_) {
       list_->AddObserver(this);
       in_list_ = true;
     }
 
     if (do_notifies_) {
-      list_->Notify(&Foo::Observe, 10);
+      list_->Notify(FROM_HERE, &Foo::Observe, 10);
     }
 
     loop_->PostTask(
         FROM_HERE,
         base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr()));
   }
 
   void Quit() {
     loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
   }
@@ skipping 62 matching lines @@
       new ObserverListThreadSafe<Foo>);
   Adder a(1);
   Adder b(-1);
   Adder c(1);
   Adder d(-1);
   ThreadSafeDisrupter evil(observer_list.get(), &c);
 
   observer_list->AddObserver(&a);
   observer_list->AddObserver(&b);
 
-  observer_list->Notify(&Foo::Observe, 10);
+  observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
   RunLoop().RunUntilIdle();
 
   observer_list->AddObserver(&evil);
   observer_list->AddObserver(&c);
   observer_list->AddObserver(&d);
 
-  observer_list->Notify(&Foo::Observe, 10);
+  observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
   RunLoop().RunUntilIdle();
 
   EXPECT_EQ(20, a.total);
   EXPECT_EQ(-20, b.total);
   EXPECT_EQ(0, c.total);
   EXPECT_EQ(-10, d.total);
 }
 
 TEST(ObserverListThreadSafeTest, RemoveObserver) {
   MessageLoop loop;
 
   scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
       new ObserverListThreadSafe<Foo>);
   Adder a(1), b(1);
 
   // A workaround for the compiler bug. See http://crbug.com/121960.
   EXPECT_NE(&a, &b);
 
   // Should do nothing.
   observer_list->RemoveObserver(&a);
   observer_list->RemoveObserver(&b);
 
-  observer_list->Notify(&Foo::Observe, 10);
+  observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
   RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, a.total);
   EXPECT_EQ(0, b.total);
 
   observer_list->AddObserver(&a);
 
   // Should also do nothing.
   observer_list->RemoveObserver(&b);
 
-  observer_list->Notify(&Foo::Observe, 10);
+  observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
   RunLoop().RunUntilIdle();
 
   EXPECT_EQ(10, a.total);
   EXPECT_EQ(0, b.total);
 }
 
 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);
+    observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
     RunLoop().RunUntilIdle();
 
     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);
+    observer_list->Notify(FROM_HERE, &Foo::Observe, 20);
     RunLoop().RunUntilIdle();
 
     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);
+  observer_list->Notify(FROM_HERE, &Foo::Observe, 30);
   RunLoop().RunUntilIdle();
 
   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) {}
@@ skipping 24 matching lines @@
 
   FooRemover a(observer_list.get());
   Adder b(1);
 
   observer_list->AddObserver(&a);
   observer_list->AddObserver(&b);
 
   a.AddFooToRemove(&a);
   a.AddFooToRemove(&b);
 
-  observer_list->Notify(&Foo::Observe, 1);
+  observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
   RunLoop().RunUntilIdle();
 }
 
 // A test driver for a multi-threaded notification loop.  Runs a number
 // of observer threads, each of which constantly adds/removes itself
 // from the observer list.  Optionally, if cross_thread_notifies is set
 // to true, the observer threads will also trigger notifications to
 // all observers.
 static void ThreadSafeObserverHarness(int num_threads,
                                       bool cross_thread_notifies) {
@@ skipping 18 matching lines @@
     threaded_observer[index] = new AddRemoveThread(observer_list.get(), false);
     EXPECT_TRUE(PlatformThread::Create(0,
                 threaded_observer[index], &threads[index]));
   }
 
   Time start = Time::Now();
   while (true) {
     if ((Time::Now() - start).InMilliseconds() > kThreadRunTime)
       break;
 
-    observer_list->Notify(&Foo::Observe, 10);
+    observer_list->Notify(FROM_HERE, &Foo::Observe, 10);
 
     RunLoop().RunUntilIdle();
   }
 
   for (int index = 0; index < num_threads; index++) {
     threaded_observer[index]->Quit();
     PlatformThread::Join(threads[index]);
   }
 }
 
@@ skipping 11 matching lines @@
 
 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);
+  observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
 }
 
 TEST(ObserverListTest, Existing) {
   ObserverList<Foo> observer_list(ObserverList<Foo>::NOTIFY_EXISTING_ONLY);
   Adder a(1);
   AddInObserve<ObserverList<Foo> > b(&observer_list);
 
   observer_list.AddObserver(&a);
   observer_list.AddObserver(&b);
 
@@ skipping 13 matching lines @@
 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);
+  observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
   RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(b.added);
   // B's adder should not have been notified because it was added during
   // notification.
   EXPECT_EQ(0, b.adder.total);
 
   // Notify again to make sure b's adder is notified.
-  observer_list->Notify(&Foo::Observe, 1);
+  observer_list->Notify(FROM_HERE, &Foo::Observe, 1);
   RunLoop().RunUntilIdle();
   EXPECT_EQ(1, b.adder.total);
 }
 
 class AddInClearObserve : public Foo {
  public:
   explicit AddInClearObserve(ObserverList<Foo>* list)
       : list_(list), added_(false), adder_(1) {}
 
   void Observe(int /* x */) override {
@@ skipping 53 matching lines @@
   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
 }  // namespace base