blob: 7e16b473d014fac155fc59263092099a1df281de [file] [log] [blame]
// 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"
#include "base/memory/weak_ptr.h"
#include "base/message_loop.h"
#include "base/threading/platform_thread.h"
#include "testing/gtest/include/gtest/gtest.h"
using base::PlatformThread;
using base::Time;
namespace {
class Foo {
public:
virtual void Observe(int x) = 0;
virtual ~Foo() {}
};
class Adder : public Foo {
public:
explicit Adder(int scaler) : total(0), scaler_(scaler) {}
virtual void Observe(int x) OVERRIDE {
total += x * scaler_;
}
virtual ~Adder() {}
int total;
private:
int scaler_;
};
class Disrupter : public Foo {
public:
Disrupter(ObserverList<Foo>* list, Foo* doomed)
: list_(list),
doomed_(doomed) {
}
virtual ~Disrupter() {}
virtual void Observe(int x) OVERRIDE {
list_->RemoveObserver(doomed_);
}
private:
ObserverList<Foo>* list_;
Foo* doomed_;
};
class ThreadSafeDisrupter : public Foo {
public:
ThreadSafeDisrupter(ObserverListThreadSafe<Foo>* list, Foo* doomed)
: list_(list),
doomed_(doomed) {
}
virtual ~ThreadSafeDisrupter() {}
virtual void Observe(int x) OVERRIDE {
list_->RemoveObserver(doomed_);
}
private:
ObserverListThreadSafe<Foo>* list_;
Foo* doomed_;
};
template <typename ObserverListType>
class AddInObserve : public Foo {
public:
explicit AddInObserve(ObserverListType* observer_list)
: added(false),
observer_list(observer_list),
adder(1) {
}
virtual void Observe(int x) OVERRIDE {
if (!added) {
added = true;
observer_list->AddObserver(&adder);
}
}
bool added;
ObserverListType* observer_list;
Adder adder;
};
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),
loop_(NULL),
in_list_(false),
start_(Time::Now()),
count_observes_(0),
count_addtask_(0),
do_notifies_(notify),
ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
}
virtual ~AddRemoveThread() {
}
virtual void ThreadMain() OVERRIDE {
loop_ = new MessageLoop(); // Fire up a message loop.
loop_->PostTask(
FROM_HERE,
base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr()));
loop_->Run();
//LOG(ERROR) << "Loop 0x" << std::hex << loop_ << " done. " <<
// count_observes_ << ", " << count_addtask_;
delete loop_;
loop_ = reinterpret_cast<MessageLoop*>(static_cast<size_t>(0xdeadbeef));
delete this;
}
bool Started() {
return loop_ != NULL;
}
// This task just keeps posting to itself in an attempt
// to race with the notifier.
void AddTask() {
count_addtask_++;
if ((Time::Now() - start_).InMilliseconds() > kThreadRunTime) {
VLOG(1) << "DONE!";
return;
}
if (!in_list_) {
list_->AddObserver(this);
in_list_ = true;
}
if (do_notifies_) {
list_->Notify(&Foo::Observe, 10);
}
loop_->PostTask(
FROM_HERE,
base::Bind(&AddRemoveThread::AddTask, weak_factory_.GetWeakPtr()));
}
void Quit() {
loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
}
virtual void Observe(int x) OVERRIDE {
count_observes_++;
// If we're getting called after we removed ourselves from
// the list, that is very bad!
DCHECK(in_list_);
// This callback should fire on the appropriate thread
EXPECT_EQ(loop_, MessageLoop::current());
list_->RemoveObserver(this);
in_list_ = false;
}
private:
ObserverListThreadSafe<Foo>* list_;
MessageLoop* loop_;
bool in_list_; // Are we currently registered for notifications.
// in_list_ is only used on |this| thread.
Time start_; // The time we started the test.
int count_observes_; // Number of times we observed.
int count_addtask_; // Number of times thread AddTask was called
bool do_notifies_; // Whether these threads should do notifications.
base::WeakPtrFactory<AddRemoveThread> weak_factory_;
};
TEST(ObserverListTest, BasicTest) {
ObserverList<Foo> observer_list;
Adder a(1), b(-1), c(1), d(-1), e(-1);
Disrupter evil(&observer_list, &c);
observer_list.AddObserver(&a);
observer_list.AddObserver(&b);
FOR_EACH_OBSERVER(Foo, observer_list, Observe(10));
observer_list.AddObserver(&evil);
observer_list.AddObserver(&c);
observer_list.AddObserver(&d);
// Removing an observer not in the list should do nothing.
observer_list.RemoveObserver(&e);
FOR_EACH_OBSERVER(Foo, observer_list, Observe(10));
EXPECT_EQ(20, a.total);
EXPECT_EQ(-20, b.total);
EXPECT_EQ(0, c.total);
EXPECT_EQ(-10, d.total);
EXPECT_EQ(0, e.total);
}
TEST(ObserverListThreadSafeTest, BasicTest) {
MessageLoop loop;
scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
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);
loop.RunUntilIdle();
observer_list->AddObserver(&evil);
observer_list->AddObserver(&c);
observer_list->AddObserver(&d);
observer_list->Notify(&Foo::Observe, 10);
loop.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);
loop.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);
loop.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);
loop.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);
loop.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);
loop.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) {}
virtual ~FooRemover() {}
void AddFooToRemove(Foo* foo) {
foos_.push_back(foo);
}
virtual void Observe(int x) OVERRIDE {
std::vector<Foo*> tmp;
tmp.swap(foos_);
for (std::vector<Foo*>::iterator it = tmp.begin();
it != tmp.end(); ++it) {
list_->RemoveObserver(*it);
}
}
private:
const scoped_refptr<ObserverListThreadSafe<Foo> > list_;
std::vector<Foo*> foos_;
};
TEST(ObserverListThreadSafeTest, RemoveMultipleObservers) {
MessageLoop loop;
scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
new ObserverListThreadSafe<Foo>);
FooRemover a(observer_list);
Adder b(1);
observer_list->AddObserver(&a);
observer_list->AddObserver(&b);
a.AddFooToRemove(&a);
a.AddFooToRemove(&b);
observer_list->Notify(&Foo::Observe, 1);
loop.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) {
MessageLoop loop;
const int kMaxThreads = 15;
num_threads = num_threads > kMaxThreads ? kMaxThreads : num_threads;
scoped_refptr<ObserverListThreadSafe<Foo> > observer_list(
new ObserverListThreadSafe<Foo>);
Adder a(1);
Adder b(-1);
Adder c(1);
Adder d(-1);
observer_list->AddObserver(&a);
observer_list->AddObserver(&b);
AddRemoveThread* threaded_observer[kMaxThreads];
base::PlatformThreadHandle threads[kMaxThreads];
for (int index = 0; index < num_threads; index++) {
threaded_observer[index] = new AddRemoveThread(observer_list.get(), false);
EXPECT_TRUE(PlatformThread::Create(0,
threaded_observer[index], &threads[index]));
}
// Wait for all threads to start do avoid NULL ptr dereference
// when calling Quit()
for (int index = 0; index < num_threads; ++index) {
while (!threaded_observer[index]->Started()) {
base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(50));
}
}
Time start = Time::Now();
while (true) {
if ((Time::Now() - start).InMilliseconds() > kThreadRunTime)
break;
observer_list->Notify(&Foo::Observe, 10);
loop.RunUntilIdle();
}
for (int index = 0; index < num_threads; index++) {
threaded_observer[index]->Quit();
PlatformThread::Join(threads[index]);
}
}
TEST(ObserverListThreadSafeTest, CrossThreadObserver) {
// 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(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<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.RunUntilIdle();
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.RunUntilIdle();
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 */) OVERRIDE {
list_->Clear();
list_->AddObserver(&adder_);
added_ = true;
}
bool added() const { return added_; }
const Adder& adder() const { return adder_; }
private:
ObserverList<Foo>* const list_;
bool added_;
Adder adder_;
};
TEST(ObserverListTest, ClearNotifyAll) {
ObserverList<Foo> observer_list;
AddInClearObserve a(&observer_list);
observer_list.AddObserver(&a);
FOR_EACH_OBSERVER(Foo, observer_list, Observe(1));
EXPECT_TRUE(a.added());
EXPECT_EQ(1, a.adder().total)
<< "Adder should observe once and have sum of 1.";
}
TEST(ObserverListTest, ClearNotifyExistingOnly) {
ObserverList<Foo> observer_list(ObserverList<Foo>::NOTIFY_EXISTING_ONLY);
AddInClearObserve a(&observer_list);
observer_list.AddObserver(&a);
FOR_EACH_OBSERVER(Foo, observer_list, Observe(1));
EXPECT_TRUE(a.added());
EXPECT_EQ(0, a.adder().total)
<< "Adder should not observe, so sum should still be 0.";
}
class ListDestructor : public Foo {
public:
explicit ListDestructor(ObserverList<Foo>* list) : list_(list) {}
virtual ~ListDestructor() {}
virtual void Observe(int x) OVERRIDE {
delete list_;
}
private:
ObserverList<Foo>* list_;
};
TEST(ObserverListTest, IteratorOutlivesList) {
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