base/task_scheduler/task_tracker_unittest.cc - Issue 2427963002: Support FileDescriptorWatcher in TaskScheduler.

Unified Diff: base/task_scheduler/task_tracker_unittest.cc

Issue 2427963002: Support FileDescriptorWatcher in TaskScheduler. (Closed)

Patch Set: nacl Created 4 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: base/task_scheduler/task_tracker_unittest.cc

diff --git a/base/task_scheduler/task_tracker_unittest.cc b/base/task_scheduler/task_tracker_unittest.cc

index 3a1ff789442496a625cf00158b02c337bdcdfe16..a8435c32a55e192d41e214c55ed4580bcaa7974e 100644

--- a/base/task_scheduler/task_tracker_unittest.cc

+++ b/base/task_scheduler/task_tracker_unittest.cc

@@ -30,8 +30,10 @@

#include "base/threading/platform_thread.h"

#include "base/threading/sequenced_task_runner_handle.h"

#include "base/threading/simple_thread.h"

+#include "base/threading/thread.h"

#include "base/threading/thread_restrictions.h"

#include "base/threading/thread_task_runner_handle.h"

+#include "build/build_config.h"

#include "testing/gtest/include/gtest/gtest.h"

namespace base {

@@ -138,7 +140,25 @@ class ScopedSetSingletonAllowed {

class TaskSchedulerTaskTrackerTest

: public testing::TestWithParam<TaskShutdownBehavior> {

protected:

- TaskSchedulerTaskTrackerTest() = default;

+ TaskSchedulerTaskTrackerTest()

+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)

+ : service_thread_("TaskSchedulerServiceThread")

+#endif

+ {

+ }

+ void SetUp() override {

+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)

+ constexpr size_t kDefaultStackSize = 0;

+ ASSERT_TRUE(service_thread_.StartWithOptions(

+ Thread::Options(MessageLoop::TYPE_IO, kDefaultStackSize)));

+#endif

+ tracker_ = MakeUnique<TaskTracker>(

+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)

+ static_cast<MessageLoopForIO*>(service_thread_.message_loop())

+#endif

+ );

+ }

// Creates a task with |shutdown_behavior|.

std::unique_ptr<Task> CreateTask(TaskShutdownBehavior shutdown_behavior) {

@@ -154,9 +174,9 @@ class TaskSchedulerTaskTrackerTest

void CallShutdownAsync() {

ASSERT_FALSE(thread_calling_shutdown_);

thread_calling_shutdown_.reset(new CallbackThread(

- Bind(&TaskTracker::Shutdown, Unretained(&tracker_))));

+ Bind(&TaskTracker::Shutdown, Unretained(tracker_.get()))));

thread_calling_shutdown_->Start();

- while (!tracker_.HasShutdownStarted())

+ while (!tracker_->HasShutdownStarted())

PlatformThread::YieldCurrentThread();

}

@@ -164,21 +184,21 @@ class TaskSchedulerTaskTrackerTest

ASSERT_TRUE(thread_calling_shutdown_);

thread_calling_shutdown_->Join();

EXPECT_TRUE(thread_calling_shutdown_->has_returned());

- EXPECT_TRUE(tracker_.IsShutdownComplete());

+ EXPECT_TRUE(tracker_->IsShutdownComplete());

}

void VerifyAsyncShutdownInProgress() {

ASSERT_TRUE(thread_calling_shutdown_);

EXPECT_FALSE(thread_calling_shutdown_->has_returned());

- EXPECT_TRUE(tracker_.HasShutdownStarted());

- EXPECT_FALSE(tracker_.IsShutdownComplete());

+ EXPECT_TRUE(tracker_->HasShutdownStarted());

+ EXPECT_FALSE(tracker_->IsShutdownComplete());

}

// Calls tracker_->Flush() on a new thread.

void CallFlushAsync() {

ASSERT_FALSE(thread_calling_flush_);

- thread_calling_flush_.reset(

- new CallbackThread(Bind(&TaskTracker::Flush, Unretained(&tracker_))));

+ thread_calling_flush_.reset(new CallbackThread(

+ Bind(&TaskTracker::Flush, Unretained(tracker_.get()))));

thread_calling_flush_->Start();

}

@@ -198,7 +218,13 @@ class TaskSchedulerTaskTrackerTest

return num_tasks_executed_;

}

- TaskTracker tracker_;

+#if defined(OS_POSIX) && !defined(OS_NACL_SFI)

+ private:

+ Thread service_thread_;

+#endif

+ protected:

+ std::unique_ptr<TaskTracker> tracker_;

private:

void RunTaskCallback() {

@@ -247,15 +273,15 @@ TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunBeforeShutdown) {

std::unique_ptr<Task> task(CreateTask(GetParam()));

// Inform |task_tracker_| that |task| will be posted.

- EXPECT_TRUE(tracker_.WillPostTask(task.get()));

+ EXPECT_TRUE(tracker_->WillPostTask(task.get()));

// Run the task.

EXPECT_EQ(0U, NumTasksExecuted());

- EXPECT_TRUE(tracker_.RunTask(std::move(task), SequenceToken::Create()));

+ EXPECT_TRUE(tracker_->RunTask(std::move(task), SequenceToken::Create()));

EXPECT_EQ(1U, NumTasksExecuted());

// Shutdown() shouldn't block.

- tracker_.Shutdown();

+ tracker_->Shutdown();

}

TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunLongTaskBeforeShutdown) {

@@ -267,11 +293,11 @@ TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunLongTaskBeforeShutdown) {

TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());

// Inform |task_tracker_| that |blocked_task| will be posted.

- EXPECT_TRUE(tracker_.WillPostTask(blocked_task.get()));

+ EXPECT_TRUE(tracker_->WillPostTask(blocked_task.get()));

// Run the task asynchronouly.

ThreadPostingAndRunningTask thread_running_task(

- &tracker_, std::move(blocked_task),

+ tracker_.get(), std::move(blocked_task),

ThreadPostingAndRunningTask::Action::RUN, false);

thread_running_task.Start();

@@ -298,13 +324,13 @@ TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunLongTaskBeforeShutdown) {

TEST_P(TaskSchedulerTaskTrackerTest, WillPostBeforeShutdownRunDuringShutdown) {

// Inform |task_tracker_| that a task will be posted.

std::unique_ptr<Task> task(CreateTask(GetParam()));

- EXPECT_TRUE(tracker_.WillPostTask(task.get()));

+ EXPECT_TRUE(tracker_->WillPostTask(task.get()));

// Inform |task_tracker_| that a BLOCK_SHUTDOWN task will be posted just to

// block shutdown.

std::unique_ptr<Task> block_shutdown_task(

CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));

- EXPECT_TRUE(tracker_.WillPostTask(block_shutdown_task.get()));

+ EXPECT_TRUE(tracker_->WillPostTask(block_shutdown_task.get()));

// Call Shutdown() asynchronously.

CallShutdownAsync();

@@ -315,13 +341,13 @@ TEST_P(TaskSchedulerTaskTrackerTest, WillPostBeforeShutdownRunDuringShutdown) {

EXPECT_EQ(0U, NumTasksExecuted());

const bool should_run = GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN;

EXPECT_EQ(should_run,

- tracker_.RunTask(std::move(task), SequenceToken::Create()));

+ tracker_->RunTask(std::move(task), SequenceToken::Create()));

EXPECT_EQ(should_run ? 1U : 0U, NumTasksExecuted());

VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();

// Unblock shutdown by running the remaining BLOCK_SHUTDOWN task.

- EXPECT_TRUE(tracker_.RunTask(std::move(block_shutdown_task),

- SequenceToken::Create()));

+ EXPECT_TRUE(tracker_->RunTask(std::move(block_shutdown_task),

+ SequenceToken::Create()));

EXPECT_EQ(should_run ? 2U : 1U, NumTasksExecuted());

WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();

}

@@ -329,7 +355,7 @@ TEST_P(TaskSchedulerTaskTrackerTest, WillPostBeforeShutdownRunDuringShutdown) {

TEST_P(TaskSchedulerTaskTrackerTest, WillPostBeforeShutdownRunAfterShutdown) {

// Inform |task_tracker_| that a task will be posted.

std::unique_ptr<Task> task(CreateTask(GetParam()));

- EXPECT_TRUE(tracker_.WillPostTask(task.get()));

+ EXPECT_TRUE(tracker_->WillPostTask(task.get()));

// Call Shutdown() asynchronously.

CallShutdownAsync();

@@ -339,7 +365,7 @@ TEST_P(TaskSchedulerTaskTrackerTest, WillPostBeforeShutdownRunAfterShutdown) {

VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();

// Run the task to unblock shutdown.

- EXPECT_TRUE(tracker_.RunTask(std::move(task), SequenceToken::Create()));

+ EXPECT_TRUE(tracker_->RunTask(std::move(task), SequenceToken::Create()));

EXPECT_EQ(1U, NumTasksExecuted());

WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();

@@ -350,7 +376,7 @@ TEST_P(TaskSchedulerTaskTrackerTest, WillPostBeforeShutdownRunAfterShutdown) {

WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();

// The task shouldn't be allowed to run after shutdown.

- EXPECT_FALSE(tracker_.RunTask(std::move(task), SequenceToken::Create()));

+ EXPECT_FALSE(tracker_->RunTask(std::move(task), SequenceToken::Create()));

EXPECT_EQ(0U, NumTasksExecuted());

}

@@ -360,7 +386,7 @@ TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunDuringShutdown) {

// block shutdown.

std::unique_ptr<Task> block_shutdown_task(

CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));

- EXPECT_TRUE(tracker_.WillPostTask(block_shutdown_task.get()));

+ EXPECT_TRUE(tracker_->WillPostTask(block_shutdown_task.get()));

// Call Shutdown() asynchronously.

CallShutdownAsync();

@@ -369,39 +395,39 @@ TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunDuringShutdown) {

if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN) {

// Inform |task_tracker_| that a BLOCK_SHUTDOWN task will be posted.

std::unique_ptr<Task> task(CreateTask(GetParam()));

- EXPECT_TRUE(tracker_.WillPostTask(task.get()));

+ EXPECT_TRUE(tracker_->WillPostTask(task.get()));

// Run the BLOCK_SHUTDOWN task.

EXPECT_EQ(0U, NumTasksExecuted());

- EXPECT_TRUE(tracker_.RunTask(std::move(task), SequenceToken::Create()));

+ EXPECT_TRUE(tracker_->RunTask(std::move(task), SequenceToken::Create()));

EXPECT_EQ(1U, NumTasksExecuted());

} else {

// It shouldn't be allowed to post a non BLOCK_SHUTDOWN task.

std::unique_ptr<Task> task(CreateTask(GetParam()));

- EXPECT_FALSE(tracker_.WillPostTask(task.get()));

+ EXPECT_FALSE(tracker_->WillPostTask(task.get()));

// Don't try to run the task, because it wasn't allowed to be posted.

}

// Unblock shutdown by running |block_shutdown_task|.

VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();

- EXPECT_TRUE(tracker_.RunTask(std::move(block_shutdown_task),

- SequenceToken::Create()));

+ EXPECT_TRUE(tracker_->RunTask(std::move(block_shutdown_task),

+ SequenceToken::Create()));

EXPECT_EQ(GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN ? 2U : 1U,

NumTasksExecuted());

WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();

}

TEST_P(TaskSchedulerTaskTrackerTest, WillPostAfterShutdown) {

- tracker_.Shutdown();

+ tracker_->Shutdown();

std::unique_ptr<Task> task(CreateTask(GetParam()));

// |task_tracker_| shouldn't allow a task to be posted after shutdown.

if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN) {

- EXPECT_DCHECK_DEATH({ tracker_.WillPostTask(task.get()); });

+ EXPECT_DCHECK_DEATH({ tracker_->WillPostTask(task.get()); });

} else {

- EXPECT_FALSE(tracker_.WillPostTask(task.get()));

+ EXPECT_FALSE(tracker_->WillPostTask(task.get()));

}

@@ -411,11 +437,10 @@ TEST_P(TaskSchedulerTaskTrackerTest, SingletonAllowed) {

const bool can_use_singletons =

(GetParam() != TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN);

- TaskTracker tracker;

std::unique_ptr<Task> task(

new Task(FROM_HERE, Bind(&ThreadRestrictions::AssertSingletonAllowed),

TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta()));

- EXPECT_TRUE(tracker.WillPostTask(task.get()));

+ EXPECT_TRUE(tracker_->WillPostTask(task.get()));

// Set the singleton allowed bit to the opposite of what it is expected to be

@@ -424,10 +449,10 @@ TEST_P(TaskSchedulerTaskTrackerTest, SingletonAllowed) {

// Running the task should fail iff the task isn't allowed to use singletons.

if (can_use_singletons) {

- EXPECT_TRUE(tracker.RunTask(std::move(task), SequenceToken::Create()));

+ EXPECT_TRUE(tracker_->RunTask(std::move(task), SequenceToken::Create()));

} else {

EXPECT_DCHECK_DEATH(

- { tracker.RunTask(std::move(task), SequenceToken::Create()); });

+ { tracker_->RunTask(std::move(task), SequenceToken::Create()); });

}

@@ -462,7 +487,7 @@ TEST_P(TaskSchedulerTaskTrackerTest, TaskRunnerHandleIsNotSetOnParallel) {

new Task(FROM_HERE, Bind(&VerifyNoTaskRunnerHandle),

TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta()));

- RunTaskRunnerHandleVerificationTask(&tracker_, std::move(verify_task));

+ RunTaskRunnerHandleVerificationTask(tracker_.get(), std::move(verify_task));

}

static void VerifySequencedTaskRunnerHandle(

@@ -485,7 +510,7 @@ TEST_P(TaskSchedulerTaskTrackerTest,

TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta()));

verify_task->sequenced_task_runner_ref = test_task_runner;

- RunTaskRunnerHandleVerificationTask(&tracker_, std::move(verify_task));

+ RunTaskRunnerHandleVerificationTask(tracker_.get(), std::move(verify_task));

}

static void VerifyThreadTaskRunnerHandle(

@@ -510,23 +535,23 @@ TEST_P(TaskSchedulerTaskTrackerTest,

TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta()));

verify_task->single_thread_task_runner_ref = test_task_runner;

- RunTaskRunnerHandleVerificationTask(&tracker_, std::move(verify_task));

+ RunTaskRunnerHandleVerificationTask(tracker_.get(), std::move(verify_task));

}

TEST_P(TaskSchedulerTaskTrackerTest, FlushPendingDelayedTask) {

const Task delayed_task(FROM_HERE, Bind(&DoNothing),

TaskTraits().WithShutdownBehavior(GetParam()),

TimeDelta::FromDays(1));

- tracker_.WillPostTask(&delayed_task);

+ tracker_->WillPostTask(&delayed_task);

// Flush() should return even if the delayed task didn't run.

- tracker_.Flush();

+ tracker_->Flush();

}

TEST_P(TaskSchedulerTaskTrackerTest, FlushPendingUndelayedTask) {

auto undelayed_task = base::MakeUnique<Task>(

FROM_HERE, Bind(&DoNothing),

TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());

- tracker_.WillPostTask(undelayed_task.get());

+ tracker_->WillPostTask(undelayed_task.get());

// Flush() shouldn't return before the undelayed task runs.

CallFlushAsync();

@@ -534,7 +559,7 @@ TEST_P(TaskSchedulerTaskTrackerTest, FlushPendingUndelayedTask) {

VERIFY_ASYNC_FLUSH_IN_PROGRESS();

// Flush() should return after the undelayed task runs.

- tracker_.RunTask(std::move(undelayed_task), SequenceToken::Create());

+ tracker_->RunTask(std::move(undelayed_task), SequenceToken::Create());

WAIT_FOR_ASYNC_FLUSH_RETURNED();

}

@@ -542,7 +567,7 @@ TEST_P(TaskSchedulerTaskTrackerTest, PostTaskDuringFlush) {

auto undelayed_task = base::MakeUnique<Task>(

FROM_HERE, Bind(&DoNothing),

TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());

- tracker_.WillPostTask(undelayed_task.get());

+ tracker_->WillPostTask(undelayed_task.get());

// Flush() shouldn't return before the undelayed task runs.

CallFlushAsync();

@@ -553,17 +578,17 @@ TEST_P(TaskSchedulerTaskTrackerTest, PostTaskDuringFlush) {

auto other_undelayed_task = base::MakeUnique<Task>(

FROM_HERE, Bind(&DoNothing),

TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());

- tracker_.WillPostTask(other_undelayed_task.get());

+ tracker_->WillPostTask(other_undelayed_task.get());

// Run the first undelayed task.

- tracker_.RunTask(std::move(undelayed_task), SequenceToken::Create());

+ tracker_->RunTask(std::move(undelayed_task), SequenceToken::Create());

// Flush() shouldn't return before the second undelayed task runs.

PlatformThread::Sleep(TestTimeouts::tiny_timeout());

VERIFY_ASYNC_FLUSH_IN_PROGRESS();

// Flush() should return after the second undelayed task runs.

- tracker_.RunTask(std::move(other_undelayed_task), SequenceToken::Create());

+ tracker_->RunTask(std::move(other_undelayed_task), SequenceToken::Create());

WAIT_FOR_ASYNC_FLUSH_RETURNED();

}

@@ -572,11 +597,11 @@ TEST_P(TaskSchedulerTaskTrackerTest, RunDelayedTaskDuringFlush) {

auto delayed_task = base::MakeUnique<Task>(

FROM_HERE, Bind(&DoNothing),

TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta::FromDays(1));

- tracker_.WillPostTask(delayed_task.get());

+ tracker_->WillPostTask(delayed_task.get());

auto undelayed_task = base::MakeUnique<Task>(

FROM_HERE, Bind(&DoNothing),

TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());

- tracker_.WillPostTask(undelayed_task.get());

+ tracker_->WillPostTask(undelayed_task.get());

// Flush() shouldn't return before the undelayed task runs.

CallFlushAsync();

@@ -584,7 +609,7 @@ TEST_P(TaskSchedulerTaskTrackerTest, RunDelayedTaskDuringFlush) {

VERIFY_ASYNC_FLUSH_IN_PROGRESS();

// Run the delayed task.

- tracker_.RunTask(std::move(delayed_task), SequenceToken::Create());

+ tracker_->RunTask(std::move(delayed_task), SequenceToken::Create());

// Flush() shouldn't return since there is still a pending undelayed

// task.

@@ -592,7 +617,7 @@ TEST_P(TaskSchedulerTaskTrackerTest, RunDelayedTaskDuringFlush) {

VERIFY_ASYNC_FLUSH_IN_PROGRESS();

// Run the undelayed task.

- tracker_.RunTask(std::move(undelayed_task), SequenceToken::Create());

+ tracker_->RunTask(std::move(undelayed_task), SequenceToken::Create());

// Flush() should now return.

WAIT_FOR_ASYNC_FLUSH_RETURNED();

@@ -606,15 +631,15 @@ TEST_P(TaskSchedulerTaskTrackerTest, FlushAfterShutdown) {

auto undelayed_task = base::MakeUnique<Task>(

FROM_HERE, Bind(&DoNothing),

TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());

- tracker_.WillPostTask(undelayed_task.get());

+ tracker_->WillPostTask(undelayed_task.get());

// Shutdown() should return immediately since there are no pending

// BLOCK_SHUTDOWN tasks.

- tracker_.Shutdown();

+ tracker_->Shutdown();

// Flush() should return immediately after shutdown, even if an

// undelayed task hasn't run.

- tracker_.Flush();

+ tracker_->Flush();

}

TEST_P(TaskSchedulerTaskTrackerTest, ShutdownDuringFlush) {

@@ -625,7 +650,7 @@ TEST_P(TaskSchedulerTaskTrackerTest, ShutdownDuringFlush) {

auto undelayed_task = base::MakeUnique<Task>(

FROM_HERE, Bind(&DoNothing),

TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());

- tracker_.WillPostTask(undelayed_task.get());

+ tracker_->WillPostTask(undelayed_task.get());

// Flush() shouldn't return before the undelayed task runs or

// shutdown completes.

@@ -635,7 +660,7 @@ TEST_P(TaskSchedulerTaskTrackerTest, ShutdownDuringFlush) {

// Shutdown() should return immediately since there are no pending

// BLOCK_SHUTDOWN tasks.

- tracker_.Shutdown();

+ tracker_->Shutdown();

// Flush() should now return, even if an undelayed task hasn't run.

WAIT_FOR_ASYNC_FLUSH_RETURNED();

@@ -669,10 +694,10 @@ TEST_F(TaskSchedulerTaskTrackerTest, CurrentSequenceToken) {

auto task = base::MakeUnique<Task>(FROM_HERE,

Bind(&ExpectSequenceToken, sequence_token),

TaskTraits(), TimeDelta());

- tracker_.WillPostTask(task.get());

+ tracker_->WillPostTask(task.get());

EXPECT_FALSE(SequenceToken::GetForCurrentThread().IsValid());

- EXPECT_TRUE(tracker_.RunTask(std::move(task), sequence_token));

+ EXPECT_TRUE(tracker_->RunTask(std::move(task), sequence_token));

EXPECT_FALSE(SequenceToken::GetForCurrentThread().IsValid());

}

@@ -682,17 +707,17 @@ TEST_F(TaskSchedulerTaskTrackerTest, LoadWillPostAndRunBeforeShutdown) {

for (size_t i = 0; i < kLoadTestNumIterations; ++i) {

threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(

- &tracker_, CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),

+ tracker_.get(), CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),

ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));

threads.back()->Start();

threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(

- &tracker_, CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN),

+ tracker_.get(), CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN),

ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));

threads.back()->Start();

threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(

- &tracker_, CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN),

+ tracker_.get(), CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN),

ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));

threads.back()->Start();

}

@@ -704,7 +729,7 @@ TEST_F(TaskSchedulerTaskTrackerTest, LoadWillPostAndRunBeforeShutdown) {

EXPECT_EQ(kLoadTestNumIterations * 3, NumTasksExecuted());

// Should return immediately because no tasks are blocking shutdown.

- tracker_.Shutdown();

+ tracker_->Shutdown();

}

TEST_F(TaskSchedulerTaskTrackerTest,

@@ -716,19 +741,19 @@ TEST_F(TaskSchedulerTaskTrackerTest,

for (size_t i = 0; i < kLoadTestNumIterations; ++i) {

tasks.push_back(CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN));

post_threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(

- &tracker_, tasks.back().get(),

+ tracker_.get(), tasks.back().get(),

ThreadPostingAndRunningTask::Action::WILL_POST, true));

post_threads.back()->Start();

tasks.push_back(CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN));

post_threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(

- &tracker_, tasks.back().get(),

+ tracker_.get(), tasks.back().get(),

ThreadPostingAndRunningTask::Action::WILL_POST, true));

post_threads.back()->Start();

tasks.push_back(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));

post_threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(

- &tracker_, tasks.back().get(),

+ tracker_.get(), tasks.back().get(),

ThreadPostingAndRunningTask::Action::WILL_POST, true));

post_threads.back()->Start();

}

@@ -744,8 +769,8 @@ TEST_F(TaskSchedulerTaskTrackerTest,

for (auto& task : tasks) {

run_threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(

- &tracker_, std::move(task), ThreadPostingAndRunningTask::Action::RUN,

- false));

+ tracker_.get(), std::move(task),

+ ThreadPostingAndRunningTask::Action::RUN, false));

run_threads.back()->Start();

}

@@ -763,7 +788,7 @@ TEST_F(TaskSchedulerTaskTrackerTest, LoadWillPostAndRunDuringShutdown) {

// block shutdown.

std::unique_ptr<Task> block_shutdown_task(

CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));

- EXPECT_TRUE(tracker_.WillPostTask(block_shutdown_task.get()));

+ EXPECT_TRUE(tracker_->WillPostTask(block_shutdown_task.get()));

// Call Shutdown() asynchronously.

CallShutdownAsync();

@@ -773,17 +798,17 @@ TEST_F(TaskSchedulerTaskTrackerTest, LoadWillPostAndRunDuringShutdown) {

for (size_t i = 0; i < kLoadTestNumIterations; ++i) {

threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(

- &tracker_, CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),

+ tracker_.get(), CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),

ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, false));

threads.back()->Start();

threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(

- &tracker_, CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN),

+ tracker_.get(), CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN),

ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, false));

threads.back()->Start();

threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(

- &tracker_, CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN),

+ tracker_.get(), CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN),

ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));

threads.back()->Start();

}

@@ -798,8 +823,8 @@ TEST_F(TaskSchedulerTaskTrackerTest, LoadWillPostAndRunDuringShutdown) {

VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();

// Unblock shutdown by running |block_shutdown_task|.

- EXPECT_TRUE(tracker_.RunTask(std::move(block_shutdown_task),

- SequenceToken::Create()));

+ EXPECT_TRUE(tracker_->RunTask(std::move(block_shutdown_task),

+ SequenceToken::Create()));

EXPECT_EQ(kLoadTestNumIterations + 1, NumTasksExecuted());

WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();

}

« base/task_scheduler/task_tracker.h ('K') | « base/task_scheduler/task_tracker.cc ('k') | no next file » | no next file with comments »