| // Copyright 2013 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/message_loop_test.h" |
| |
| #include <stddef.h> |
| |
| #include <utility> |
| |
| #include "base/bind.h" |
| #include "base/macros.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/run_loop.h" |
| #include "base/single_thread_task_runner.h" |
| #include "base/synchronization/waitable_event.h" |
| #include "base/threading/thread.h" |
| #include "base/threading/thread_task_runner_handle.h" |
| |
| namespace base { |
| namespace test { |
| |
| namespace { |
| |
| class Foo : public RefCounted<Foo> { |
| public: |
| Foo() : test_count_(0) { |
| } |
| |
| void Test0() { |
| ++test_count_; |
| } |
| |
| void Test1ConstRef(const std::string& a) { |
| ++test_count_; |
| result_.append(a); |
| } |
| |
| void Test1Ptr(std::string* a) { |
| ++test_count_; |
| result_.append(*a); |
| } |
| |
| void Test1Int(int a) { |
| test_count_ += a; |
| } |
| |
| void Test2Ptr(std::string* a, std::string* b) { |
| ++test_count_; |
| result_.append(*a); |
| result_.append(*b); |
| } |
| |
| void Test2Mixed(const std::string& a, std::string* b) { |
| ++test_count_; |
| result_.append(a); |
| result_.append(*b); |
| } |
| |
| int test_count() const { return test_count_; } |
| const std::string& result() const { return result_; } |
| |
| private: |
| friend class RefCounted<Foo>; |
| |
| ~Foo() {} |
| |
| int test_count_; |
| std::string result_; |
| |
| DISALLOW_COPY_AND_ASSIGN(Foo); |
| }; |
| |
| // This function runs slowly to simulate a large amount of work being done. |
| void SlowFunc(TimeDelta pause, int* quit_counter) { |
| PlatformThread::Sleep(pause); |
| if (--(*quit_counter) == 0) |
| MessageLoop::current()->QuitWhenIdle(); |
| } |
| |
| // This function records the time when Run was called in a Time object, which is |
| // useful for building a variety of MessageLoop tests. |
| // TODO(sky): remove? |
| void RecordRunTimeFunc(Time* run_time, int* quit_counter) { |
| *run_time = Time::Now(); |
| |
| // Cause our Run function to take some time to execute. As a result we can |
| // count on subsequent RecordRunTimeFunc()s running at a future time, |
| // without worry about the resolution of our system clock being an issue. |
| SlowFunc(TimeDelta::FromMilliseconds(10), quit_counter); |
| } |
| |
| } // namespace |
| |
| void RunTest_PostTask(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| // Add tests to message loop |
| scoped_refptr<Foo> foo(new Foo()); |
| std::string a("a"), b("b"), c("c"), d("d"); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind(&Foo::Test0, foo)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&Foo::Test1ConstRef, foo, a)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&Foo::Test1Ptr, foo, &b)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&Foo::Test1Int, foo, 100)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&Foo::Test2Ptr, foo, &a, &c)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&Foo::Test2Mixed, foo, a, &d)); |
| // After all tests, post a message that will shut down the message loop |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, |
| Bind(&MessageLoop::QuitWhenIdle, Unretained(MessageLoop::current()))); |
| |
| // Now kick things off |
| RunLoop().Run(); |
| |
| EXPECT_EQ(foo->test_count(), 105); |
| EXPECT_EQ(foo->result(), "abacad"); |
| } |
| |
| void RunTest_PostDelayedTask_Basic(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| // Test that PostDelayedTask results in a delayed task. |
| |
| const TimeDelta kDelay = TimeDelta::FromMilliseconds(100); |
| |
| int num_tasks = 1; |
| Time run_time; |
| |
| loop.task_runner()->PostDelayedTask( |
| FROM_HERE, Bind(&RecordRunTimeFunc, &run_time, &num_tasks), kDelay); |
| |
| Time time_before_run = Time::Now(); |
| RunLoop().Run(); |
| Time time_after_run = Time::Now(); |
| |
| EXPECT_EQ(0, num_tasks); |
| EXPECT_LT(kDelay, time_after_run - time_before_run); |
| } |
| |
| void RunTest_PostDelayedTask_InDelayOrder(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| // Test that two tasks with different delays run in the right order. |
| int num_tasks = 2; |
| Time run_time1, run_time2; |
| |
| loop.task_runner()->PostDelayedTask( |
| FROM_HERE, Bind(&RecordRunTimeFunc, &run_time1, &num_tasks), |
| TimeDelta::FromMilliseconds(200)); |
| // If we get a large pause in execution (due to a context switch) here, this |
| // test could fail. |
| loop.task_runner()->PostDelayedTask( |
| FROM_HERE, Bind(&RecordRunTimeFunc, &run_time2, &num_tasks), |
| TimeDelta::FromMilliseconds(10)); |
| |
| RunLoop().Run(); |
| EXPECT_EQ(0, num_tasks); |
| |
| EXPECT_TRUE(run_time2 < run_time1); |
| } |
| |
| void RunTest_PostDelayedTask_InPostOrder(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| // Test that two tasks with the same delay run in the order in which they |
| // were posted. |
| // |
| // NOTE: This is actually an approximate test since the API only takes a |
| // "delay" parameter, so we are not exactly simulating two tasks that get |
| // posted at the exact same time. It would be nice if the API allowed us to |
| // specify the desired run time. |
| |
| const TimeDelta kDelay = TimeDelta::FromMilliseconds(100); |
| |
| int num_tasks = 2; |
| Time run_time1, run_time2; |
| |
| loop.task_runner()->PostDelayedTask( |
| FROM_HERE, Bind(&RecordRunTimeFunc, &run_time1, &num_tasks), kDelay); |
| loop.task_runner()->PostDelayedTask( |
| FROM_HERE, Bind(&RecordRunTimeFunc, &run_time2, &num_tasks), kDelay); |
| |
| RunLoop().Run(); |
| EXPECT_EQ(0, num_tasks); |
| |
| EXPECT_TRUE(run_time1 < run_time2); |
| } |
| |
| void RunTest_PostDelayedTask_InPostOrder_2(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| // Test that a delayed task still runs after a normal tasks even if the |
| // normal tasks take a long time to run. |
| |
| const TimeDelta kPause = TimeDelta::FromMilliseconds(50); |
| |
| int num_tasks = 2; |
| Time run_time; |
| |
| loop.task_runner()->PostTask(FROM_HERE, Bind(&SlowFunc, kPause, &num_tasks)); |
| loop.task_runner()->PostDelayedTask( |
| FROM_HERE, Bind(&RecordRunTimeFunc, &run_time, &num_tasks), |
| TimeDelta::FromMilliseconds(10)); |
| |
| Time time_before_run = Time::Now(); |
| RunLoop().Run(); |
| Time time_after_run = Time::Now(); |
| |
| EXPECT_EQ(0, num_tasks); |
| |
| EXPECT_LT(kPause, time_after_run - time_before_run); |
| } |
| |
| void RunTest_PostDelayedTask_InPostOrder_3(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| // Test that a delayed task still runs after a pile of normal tasks. The key |
| // difference between this test and the previous one is that here we return |
| // the MessageLoop a lot so we give the MessageLoop plenty of opportunities |
| // to maybe run the delayed task. It should know not to do so until the |
| // delayed task's delay has passed. |
| |
| int num_tasks = 11; |
| Time run_time1, run_time2; |
| |
| // Clutter the ML with tasks. |
| for (int i = 1; i < num_tasks; ++i) |
| loop.task_runner()->PostTask( |
| FROM_HERE, Bind(&RecordRunTimeFunc, &run_time1, &num_tasks)); |
| |
| loop.task_runner()->PostDelayedTask( |
| FROM_HERE, Bind(&RecordRunTimeFunc, &run_time2, &num_tasks), |
| TimeDelta::FromMilliseconds(1)); |
| |
| RunLoop().Run(); |
| EXPECT_EQ(0, num_tasks); |
| |
| EXPECT_TRUE(run_time2 > run_time1); |
| } |
| |
| void RunTest_PostDelayedTask_SharedTimer(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| // Test that the interval of the timer, used to run the next delayed task, is |
| // set to a value corresponding to when the next delayed task should run. |
| |
| // By setting num_tasks to 1, we ensure that the first task to run causes the |
| // run loop to exit. |
| int num_tasks = 1; |
| Time run_time1, run_time2; |
| |
| loop.task_runner()->PostDelayedTask( |
| FROM_HERE, Bind(&RecordRunTimeFunc, &run_time1, &num_tasks), |
| TimeDelta::FromSeconds(1000)); |
| loop.task_runner()->PostDelayedTask( |
| FROM_HERE, Bind(&RecordRunTimeFunc, &run_time2, &num_tasks), |
| TimeDelta::FromMilliseconds(10)); |
| |
| Time start_time = Time::Now(); |
| |
| RunLoop().Run(); |
| EXPECT_EQ(0, num_tasks); |
| |
| // Ensure that we ran in far less time than the slower timer. |
| TimeDelta total_time = Time::Now() - start_time; |
| EXPECT_GT(5000, total_time.InMilliseconds()); |
| |
| // In case both timers somehow run at nearly the same time, sleep a little |
| // and then run all pending to force them both to have run. This is just |
| // encouraging flakiness if there is any. |
| PlatformThread::Sleep(TimeDelta::FromMilliseconds(100)); |
| RunLoop().RunUntilIdle(); |
| |
| EXPECT_TRUE(run_time1.is_null()); |
| EXPECT_FALSE(run_time2.is_null()); |
| } |
| |
| // This is used to inject a test point for recording the destructor calls for |
| // Closure objects send to MessageLoop::PostTask(). It is awkward usage since we |
| // are trying to hook the actual destruction, which is not a common operation. |
| class RecordDeletionProbe : public RefCounted<RecordDeletionProbe> { |
| public: |
| RecordDeletionProbe(RecordDeletionProbe* post_on_delete, bool* was_deleted) |
| : post_on_delete_(post_on_delete), was_deleted_(was_deleted) { |
| } |
| void Run() {} |
| |
| private: |
| friend class RefCounted<RecordDeletionProbe>; |
| |
| ~RecordDeletionProbe() { |
| *was_deleted_ = true; |
| if (post_on_delete_.get()) |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&RecordDeletionProbe::Run, post_on_delete_)); |
| } |
| |
| scoped_refptr<RecordDeletionProbe> post_on_delete_; |
| bool* was_deleted_; |
| }; |
| |
| void RunTest_EnsureDeletion(MessagePumpFactory factory) { |
| bool a_was_deleted = false; |
| bool b_was_deleted = false; |
| { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| loop.task_runner()->PostTask( |
| FROM_HERE, Bind(&RecordDeletionProbe::Run, |
| new RecordDeletionProbe(NULL, &a_was_deleted))); |
| // TODO(ajwong): Do we really need 1000ms here? |
| loop.task_runner()->PostDelayedTask( |
| FROM_HERE, Bind(&RecordDeletionProbe::Run, |
| new RecordDeletionProbe(NULL, &b_was_deleted)), |
| TimeDelta::FromMilliseconds(1000)); |
| } |
| EXPECT_TRUE(a_was_deleted); |
| EXPECT_TRUE(b_was_deleted); |
| } |
| |
| void RunTest_EnsureDeletion_Chain(MessagePumpFactory factory) { |
| bool a_was_deleted = false; |
| bool b_was_deleted = false; |
| bool c_was_deleted = false; |
| { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| // The scoped_refptr for each of the below is held either by the chained |
| // RecordDeletionProbe, or the bound RecordDeletionProbe::Run() callback. |
| RecordDeletionProbe* a = new RecordDeletionProbe(NULL, &a_was_deleted); |
| RecordDeletionProbe* b = new RecordDeletionProbe(a, &b_was_deleted); |
| RecordDeletionProbe* c = new RecordDeletionProbe(b, &c_was_deleted); |
| loop.task_runner()->PostTask(FROM_HERE, Bind(&RecordDeletionProbe::Run, c)); |
| } |
| EXPECT_TRUE(a_was_deleted); |
| EXPECT_TRUE(b_was_deleted); |
| EXPECT_TRUE(c_was_deleted); |
| } |
| |
| void NestingFunc(int* depth) { |
| if (*depth > 0) { |
| *depth -= 1; |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&NestingFunc, depth)); |
| |
| MessageLoop::current()->SetNestableTasksAllowed(true); |
| RunLoop().Run(); |
| } |
| MessageLoop::current()->QuitWhenIdle(); |
| } |
| |
| void RunTest_Nesting(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| int depth = 100; |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&NestingFunc, &depth)); |
| RunLoop().Run(); |
| EXPECT_EQ(depth, 0); |
| } |
| |
| // A NestingObserver that tracks the number of nested message loop starts it |
| // has seen. |
| class TestNestingObserver : public MessageLoop::NestingObserver { |
| public: |
| TestNestingObserver() {} |
| ~TestNestingObserver() override {} |
| |
| int begin_nested_loop_count() const { return begin_nested_loop_count_; } |
| |
| // MessageLoop::NestingObserver: |
| void OnBeginNestedMessageLoop() override { begin_nested_loop_count_++; } |
| |
| private: |
| int begin_nested_loop_count_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(TestNestingObserver); |
| }; |
| |
| void ExpectOneBeginNestedLoop(TestNestingObserver* observer) { |
| EXPECT_EQ(1, observer->begin_nested_loop_count()); |
| } |
| |
| // Starts a nested message loop. |
| void RunNestedLoop(TestNestingObserver* observer, |
| const Closure& quit_outer_loop) { |
| // The nested loop hasn't started yet. |
| EXPECT_EQ(0, observer->begin_nested_loop_count()); |
| |
| MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current()); |
| RunLoop nested_loop; |
| // Verify that by the time the first task is run the observer has seen the |
| // message loop begin. |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&ExpectOneBeginNestedLoop, observer)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, nested_loop.QuitClosure()); |
| nested_loop.Run(); |
| |
| // Quitting message loops doesn't change the begin count. |
| EXPECT_EQ(1, observer->begin_nested_loop_count()); |
| |
| quit_outer_loop.Run(); |
| } |
| |
| // Tests that a NestingObserver is notified when a nested message loop begins. |
| void RunTest_NestingObserver(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop outer_loop(std::move(pump)); |
| |
| // Observe the outer loop for nested message loops beginning. |
| TestNestingObserver nesting_observer; |
| outer_loop.AddNestingObserver(&nesting_observer); |
| |
| // Post a task that runs a nested message loop. |
| outer_loop.task_runner()->PostTask(FROM_HERE, |
| Bind(&RunNestedLoop, &nesting_observer, |
| outer_loop.QuitWhenIdleClosure())); |
| RunLoop().Run(); |
| |
| outer_loop.RemoveNestingObserver(&nesting_observer); |
| } |
| |
| enum TaskType { |
| MESSAGEBOX, |
| ENDDIALOG, |
| RECURSIVE, |
| TIMEDMESSAGELOOP, |
| QUITMESSAGELOOP, |
| ORDERED, |
| PUMPS, |
| SLEEP, |
| RUNS, |
| }; |
| |
| struct TaskItem { |
| TaskItem(TaskType t, int c, bool s) |
| : type(t), |
| cookie(c), |
| start(s) { |
| } |
| |
| TaskType type; |
| int cookie; |
| bool start; |
| |
| bool operator == (const TaskItem& other) const { |
| return type == other.type && cookie == other.cookie && start == other.start; |
| } |
| }; |
| |
| std::ostream& operator <<(std::ostream& os, TaskType type) { |
| switch (type) { |
| case MESSAGEBOX: os << "MESSAGEBOX"; break; |
| case ENDDIALOG: os << "ENDDIALOG"; break; |
| case RECURSIVE: os << "RECURSIVE"; break; |
| case TIMEDMESSAGELOOP: os << "TIMEDMESSAGELOOP"; break; |
| case QUITMESSAGELOOP: os << "QUITMESSAGELOOP"; break; |
| case ORDERED: os << "ORDERED"; break; |
| case PUMPS: os << "PUMPS"; break; |
| case SLEEP: os << "SLEEP"; break; |
| default: |
| NOTREACHED(); |
| os << "Unknown TaskType"; |
| break; |
| } |
| return os; |
| } |
| |
| std::ostream& operator <<(std::ostream& os, const TaskItem& item) { |
| if (item.start) |
| return os << item.type << " " << item.cookie << " starts"; |
| else |
| return os << item.type << " " << item.cookie << " ends"; |
| } |
| |
| class TaskList { |
| public: |
| void RecordStart(TaskType type, int cookie) { |
| TaskItem item(type, cookie, true); |
| DVLOG(1) << item; |
| task_list_.push_back(item); |
| } |
| |
| void RecordEnd(TaskType type, int cookie) { |
| TaskItem item(type, cookie, false); |
| DVLOG(1) << item; |
| task_list_.push_back(item); |
| } |
| |
| size_t Size() { |
| return task_list_.size(); |
| } |
| |
| TaskItem Get(int n) { |
| return task_list_[n]; |
| } |
| |
| private: |
| std::vector<TaskItem> task_list_; |
| }; |
| |
| void RecursiveFunc(TaskList* order, int cookie, int depth, |
| bool is_reentrant) { |
| order->RecordStart(RECURSIVE, cookie); |
| if (depth > 0) { |
| if (is_reentrant) |
| MessageLoop::current()->SetNestableTasksAllowed(true); |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, |
| Bind(&RecursiveFunc, order, cookie, depth - 1, is_reentrant)); |
| } |
| order->RecordEnd(RECURSIVE, cookie); |
| } |
| |
| void QuitFunc(TaskList* order, int cookie) { |
| order->RecordStart(QUITMESSAGELOOP, cookie); |
| MessageLoop::current()->QuitWhenIdle(); |
| order->RecordEnd(QUITMESSAGELOOP, cookie); |
| } |
| void RunTest_RecursiveDenial1(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| EXPECT_TRUE(MessageLoop::current()->NestableTasksAllowed()); |
| TaskList order; |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&RecursiveFunc, &order, 1, 2, false)); |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&RecursiveFunc, &order, 2, 2, false)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&QuitFunc, &order, 3)); |
| |
| RunLoop().Run(); |
| |
| // FIFO order. |
| ASSERT_EQ(14U, order.Size()); |
| EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true)); |
| EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false)); |
| EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true)); |
| EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false)); |
| EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true)); |
| EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false)); |
| EXPECT_EQ(order.Get(6), TaskItem(RECURSIVE, 1, true)); |
| EXPECT_EQ(order.Get(7), TaskItem(RECURSIVE, 1, false)); |
| EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true)); |
| EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false)); |
| EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true)); |
| EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false)); |
| EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 2, true)); |
| EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 2, false)); |
| } |
| |
| void RecursiveSlowFunc(TaskList* order, int cookie, int depth, |
| bool is_reentrant) { |
| RecursiveFunc(order, cookie, depth, is_reentrant); |
| PlatformThread::Sleep(TimeDelta::FromMilliseconds(10)); |
| } |
| |
| void OrderedFunc(TaskList* order, int cookie) { |
| order->RecordStart(ORDERED, cookie); |
| order->RecordEnd(ORDERED, cookie); |
| } |
| |
| void RunTest_RecursiveDenial3(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| EXPECT_TRUE(MessageLoop::current()->NestableTasksAllowed()); |
| TaskList order; |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&RecursiveSlowFunc, &order, 1, 2, false)); |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&RecursiveSlowFunc, &order, 2, 2, false)); |
| ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
| FROM_HERE, Bind(&OrderedFunc, &order, 3), TimeDelta::FromMilliseconds(5)); |
| ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
| FROM_HERE, Bind(&QuitFunc, &order, 4), TimeDelta::FromMilliseconds(5)); |
| |
| RunLoop().Run(); |
| |
| // FIFO order. |
| ASSERT_EQ(16U, order.Size()); |
| EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true)); |
| EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false)); |
| EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true)); |
| EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false)); |
| EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 1, true)); |
| EXPECT_EQ(order.Get(5), TaskItem(RECURSIVE, 1, false)); |
| EXPECT_EQ(order.Get(6), TaskItem(ORDERED, 3, true)); |
| EXPECT_EQ(order.Get(7), TaskItem(ORDERED, 3, false)); |
| EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true)); |
| EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false)); |
| EXPECT_EQ(order.Get(10), TaskItem(QUITMESSAGELOOP, 4, true)); |
| EXPECT_EQ(order.Get(11), TaskItem(QUITMESSAGELOOP, 4, false)); |
| EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 1, true)); |
| EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 1, false)); |
| EXPECT_EQ(order.Get(14), TaskItem(RECURSIVE, 2, true)); |
| EXPECT_EQ(order.Get(15), TaskItem(RECURSIVE, 2, false)); |
| } |
| |
| void RunTest_RecursiveSupport1(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| TaskList order; |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&RecursiveFunc, &order, 1, 2, true)); |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&RecursiveFunc, &order, 2, 2, true)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&QuitFunc, &order, 3)); |
| |
| RunLoop().Run(); |
| |
| // FIFO order. |
| ASSERT_EQ(14U, order.Size()); |
| EXPECT_EQ(order.Get(0), TaskItem(RECURSIVE, 1, true)); |
| EXPECT_EQ(order.Get(1), TaskItem(RECURSIVE, 1, false)); |
| EXPECT_EQ(order.Get(2), TaskItem(RECURSIVE, 2, true)); |
| EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false)); |
| EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true)); |
| EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false)); |
| EXPECT_EQ(order.Get(6), TaskItem(RECURSIVE, 1, true)); |
| EXPECT_EQ(order.Get(7), TaskItem(RECURSIVE, 1, false)); |
| EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true)); |
| EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false)); |
| EXPECT_EQ(order.Get(10), TaskItem(RECURSIVE, 1, true)); |
| EXPECT_EQ(order.Get(11), TaskItem(RECURSIVE, 1, false)); |
| EXPECT_EQ(order.Get(12), TaskItem(RECURSIVE, 2, true)); |
| EXPECT_EQ(order.Get(13), TaskItem(RECURSIVE, 2, false)); |
| } |
| |
| // Tests that non nestable tasks run in FIFO if there are no nested loops. |
| void RunTest_NonNestableWithNoNesting(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| TaskList order; |
| |
| ThreadTaskRunnerHandle::Get()->PostNonNestableTask( |
| FROM_HERE, Bind(&OrderedFunc, &order, 1)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 2)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&QuitFunc, &order, 3)); |
| RunLoop().Run(); |
| |
| // FIFO order. |
| ASSERT_EQ(6U, order.Size()); |
| EXPECT_EQ(order.Get(0), TaskItem(ORDERED, 1, true)); |
| EXPECT_EQ(order.Get(1), TaskItem(ORDERED, 1, false)); |
| EXPECT_EQ(order.Get(2), TaskItem(ORDERED, 2, true)); |
| EXPECT_EQ(order.Get(3), TaskItem(ORDERED, 2, false)); |
| EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true)); |
| EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false)); |
| } |
| |
| void FuncThatPumps(TaskList* order, int cookie) { |
| order->RecordStart(PUMPS, cookie); |
| { |
| MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current()); |
| RunLoop().RunUntilIdle(); |
| } |
| order->RecordEnd(PUMPS, cookie); |
| } |
| |
| void SleepFunc(TaskList* order, int cookie, TimeDelta delay) { |
| order->RecordStart(SLEEP, cookie); |
| PlatformThread::Sleep(delay); |
| order->RecordEnd(SLEEP, cookie); |
| } |
| |
| // Tests that non nestable tasks don't run when there's code in the call stack. |
| void RunTest_NonNestableInNestedLoop(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| TaskList order; |
| |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&FuncThatPumps, &order, 1)); |
| ThreadTaskRunnerHandle::Get()->PostNonNestableTask( |
| FROM_HERE, Bind(&OrderedFunc, &order, 2)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 3)); |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&SleepFunc, &order, 4, TimeDelta::FromMilliseconds(50))); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 5)); |
| ThreadTaskRunnerHandle::Get()->PostNonNestableTask( |
| FROM_HERE, Bind(&QuitFunc, &order, 6)); |
| |
| RunLoop().Run(); |
| |
| // FIFO order. |
| ASSERT_EQ(12U, order.Size()); |
| EXPECT_EQ(order.Get(0), TaskItem(PUMPS, 1, true)); |
| EXPECT_EQ(order.Get(1), TaskItem(ORDERED, 3, true)); |
| EXPECT_EQ(order.Get(2), TaskItem(ORDERED, 3, false)); |
| EXPECT_EQ(order.Get(3), TaskItem(SLEEP, 4, true)); |
| EXPECT_EQ(order.Get(4), TaskItem(SLEEP, 4, false)); |
| EXPECT_EQ(order.Get(5), TaskItem(ORDERED, 5, true)); |
| EXPECT_EQ(order.Get(6), TaskItem(ORDERED, 5, false)); |
| EXPECT_EQ(order.Get(7), TaskItem(PUMPS, 1, false)); |
| EXPECT_EQ(order.Get(8), TaskItem(ORDERED, 2, true)); |
| EXPECT_EQ(order.Get(9), TaskItem(ORDERED, 2, false)); |
| EXPECT_EQ(order.Get(10), TaskItem(QUITMESSAGELOOP, 6, true)); |
| EXPECT_EQ(order.Get(11), TaskItem(QUITMESSAGELOOP, 6, false)); |
| } |
| |
| void FuncThatRuns(TaskList* order, int cookie, RunLoop* run_loop) { |
| order->RecordStart(RUNS, cookie); |
| { |
| MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current()); |
| run_loop->Run(); |
| } |
| order->RecordEnd(RUNS, cookie); |
| } |
| |
| void FuncThatQuitsNow() { |
| MessageLoop::current()->QuitNow(); |
| } |
| // Tests RunLoopQuit only quits the corresponding MessageLoop::Run. |
| void RunTest_QuitNow(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| TaskList order; |
| |
| RunLoop run_loop; |
| |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&FuncThatRuns, &order, 1, Unretained(&run_loop))); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 2)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind(&FuncThatQuitsNow)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 3)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind(&FuncThatQuitsNow)); |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&OrderedFunc, &order, 4)); // never runs |
| |
| RunLoop().Run(); |
| |
| ASSERT_EQ(6U, order.Size()); |
| int task_index = 0; |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, false)); |
| EXPECT_EQ(static_cast<size_t>(task_index), order.Size()); |
| } |
| |
| // Tests RunLoopQuit only quits the corresponding MessageLoop::Run. |
| void RunTest_RunLoopQuitTop(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| TaskList order; |
| |
| RunLoop outer_run_loop; |
| RunLoop nested_run_loop; |
| |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop))); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| outer_run_loop.QuitClosure()); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 2)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| nested_run_loop.QuitClosure()); |
| |
| outer_run_loop.Run(); |
| |
| ASSERT_EQ(4U, order.Size()); |
| int task_index = 0; |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false)); |
| EXPECT_EQ(static_cast<size_t>(task_index), order.Size()); |
| } |
| |
| // Tests RunLoopQuit only quits the corresponding MessageLoop::Run. |
| void RunTest_RunLoopQuitNested(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| TaskList order; |
| |
| RunLoop outer_run_loop; |
| RunLoop nested_run_loop; |
| |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop))); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| nested_run_loop.QuitClosure()); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 2)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| outer_run_loop.QuitClosure()); |
| |
| outer_run_loop.Run(); |
| |
| ASSERT_EQ(4U, order.Size()); |
| int task_index = 0; |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false)); |
| EXPECT_EQ(static_cast<size_t>(task_index), order.Size()); |
| } |
| |
| // Tests RunLoopQuit only quits the corresponding MessageLoop::Run. |
| void RunTest_RunLoopQuitBogus(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| TaskList order; |
| |
| RunLoop outer_run_loop; |
| RunLoop nested_run_loop; |
| RunLoop bogus_run_loop; |
| |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&FuncThatRuns, &order, 1, Unretained(&nested_run_loop))); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| bogus_run_loop.QuitClosure()); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 2)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| outer_run_loop.QuitClosure()); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| nested_run_loop.QuitClosure()); |
| |
| outer_run_loop.Run(); |
| |
| ASSERT_EQ(4U, order.Size()); |
| int task_index = 0; |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false)); |
| EXPECT_EQ(static_cast<size_t>(task_index), order.Size()); |
| } |
| |
| // Tests RunLoopQuit only quits the corresponding MessageLoop::Run. |
| void RunTest_RunLoopQuitDeep(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| TaskList order; |
| |
| RunLoop outer_run_loop; |
| RunLoop nested_loop1; |
| RunLoop nested_loop2; |
| RunLoop nested_loop3; |
| RunLoop nested_loop4; |
| |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&FuncThatRuns, &order, 1, Unretained(&nested_loop1))); |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&FuncThatRuns, &order, 2, Unretained(&nested_loop2))); |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&FuncThatRuns, &order, 3, Unretained(&nested_loop3))); |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&FuncThatRuns, &order, 4, Unretained(&nested_loop4))); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 5)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| outer_run_loop.QuitClosure()); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 6)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| nested_loop1.QuitClosure()); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 7)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| nested_loop2.QuitClosure()); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 8)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| nested_loop3.QuitClosure()); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 9)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| nested_loop4.QuitClosure()); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 10)); |
| |
| outer_run_loop.Run(); |
| |
| ASSERT_EQ(18U, order.Size()); |
| int task_index = 0; |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 2, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 3, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 4, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 5, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 5, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 6, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 6, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 7, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 7, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 8, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 8, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 9, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 9, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 4, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 3, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 2, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false)); |
| EXPECT_EQ(static_cast<size_t>(task_index), order.Size()); |
| } |
| |
| // Tests RunLoopQuit works before RunWithID. |
| void RunTest_RunLoopQuitOrderBefore(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| TaskList order; |
| |
| RunLoop run_loop; |
| |
| run_loop.Quit(); |
| |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&OrderedFunc, &order, 1)); // never runs |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&FuncThatQuitsNow)); // never runs |
| |
| run_loop.Run(); |
| |
| ASSERT_EQ(0U, order.Size()); |
| } |
| |
| // Tests RunLoopQuit works during RunWithID. |
| void RunTest_RunLoopQuitOrderDuring(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| TaskList order; |
| |
| RunLoop run_loop; |
| |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 1)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, run_loop.QuitClosure()); |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&OrderedFunc, &order, 2)); // never runs |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&FuncThatQuitsNow)); // never runs |
| |
| run_loop.Run(); |
| |
| ASSERT_EQ(2U, order.Size()); |
| int task_index = 0; |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 1, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 1, false)); |
| EXPECT_EQ(static_cast<size_t>(task_index), order.Size()); |
| } |
| |
| // Tests RunLoopQuit works after RunWithID. |
| void RunTest_RunLoopQuitOrderAfter(MessagePumpFactory factory) { |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| |
| TaskList order; |
| |
| RunLoop run_loop; |
| |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&FuncThatRuns, &order, 1, Unretained(&run_loop))); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 2)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind(&FuncThatQuitsNow)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 3)); |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, run_loop.QuitClosure()); // has no affect |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
| Bind(&OrderedFunc, &order, 4)); |
| ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind(&FuncThatQuitsNow)); |
| |
| RunLoop outer_run_loop; |
| outer_run_loop.Run(); |
| |
| ASSERT_EQ(8U, order.Size()); |
| int task_index = 0; |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, false)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 4, true)); |
| EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 4, false)); |
| EXPECT_EQ(static_cast<size_t>(task_index), order.Size()); |
| } |
| |
| void PostNTasksThenQuit(int posts_remaining) { |
| if (posts_remaining > 1) { |
| ThreadTaskRunnerHandle::Get()->PostTask( |
| FROM_HERE, Bind(&PostNTasksThenQuit, posts_remaining - 1)); |
| } else { |
| MessageLoop::current()->QuitWhenIdle(); |
| } |
| } |
| |
| // There was a bug in the MessagePumpGLib where posting tasks recursively |
| // caused the message loop to hang, due to the buffer of the internal pipe |
| // becoming full. Test all MessageLoop types to ensure this issue does not |
| // exist in other MessagePumps. |
| // |
| // On Linux, the pipe buffer size is 64KiB by default. The bug caused one |
| // byte accumulated in the pipe per two posts, so we should repeat 128K |
| // times to reproduce the bug. |
| void RunTest_RecursivePosts(MessagePumpFactory factory) { |
| const int kNumTimes = 1 << 17; |
| std::unique_ptr<MessagePump> pump(factory()); |
| MessageLoop loop(std::move(pump)); |
| loop.task_runner()->PostTask(FROM_HERE, Bind(&PostNTasksThenQuit, kNumTimes)); |
| RunLoop().Run(); |
| } |
| |
| } // namespace test |
| } // namespace base |