TaskScheduler [5/9] Task Tracker

base/task_scheduler/task_tracker_unittest.cc

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
new file mode 100644
index 0000000000000000000000000000000000000000..d72b4abfc0dc9509507f60757ac710d0abb96cf1
--- /dev/null
+++ b/base/task_scheduler/task_tracker_unittest.cc
@@ -0,0 +1,471 @@
+// Copyright 2016 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/task_scheduler/task_tracker.h"
+
+#include <queue>
+
+#include "base/bind.h"
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/task_scheduler/task.h"
+#include "base/task_scheduler/task_traits.h"
+#include "base/threading/platform_thread.h"
+#include "base/threading/simple_thread.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+namespace internal {
+
+namespace {
+
+class ThreadCallingShutdown : public SimpleThread {
+ public:
+  explicit ThreadCallingShutdown(TaskTracker* tracker)
+      : SimpleThread("ThreadCallingShutdown"),
+        tracker_(tracker),
+        has_returned_(false) {}
+
+  // Returns true once the call to Shutdown() has returned.
+  bool has_returned() const { return has_returned_; }
+
+ private:
+  void Run() override {
+    tracker_->Shutdown();
+    has_returned_ = true;
+  }
+
+  TaskTracker* const tracker_;
+  bool has_returned_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadCallingShutdown);
+};
+
+class TaskSchedulerTaskTrackerTest
+    : public testing::Test,
+      public ::testing::WithParamInterface<TaskShutdownBehavior> {

[gab, 2016/03/09 21:53:25]

You can use testing::TestWithParam<TaskShutdownBehavior> instead of both ::Test
and ::WithParamInterface.

[fdoray, 2016/03/15 17:28:09]

Done.

+ public:
+  TaskSchedulerTaskTrackerTest() : num_tasks_executed_(0) {}

[gab, 2016/03/09 21:53:25]

Can initialize member inline now with C++11 :-)

(same for |has_returned_| above)

I tend to prefer that as it's clearer in a single read that it's initialized and
what it's initialized to.

[fdoray, 2016/03/15 17:28:09]

Done.

+
+  // Creates a task with |shutdown_behavior|.
+  scoped_ptr<Task> CreateTask(TaskShutdownBehavior shutdown_behavior) {
+    return make_scoped_ptr(new Task(
+        FROM_HERE,
+        Bind(&TaskSchedulerTaskTrackerTest::RunTaskCallback, Unretained(this)),
+        TaskTraits().WithShutdownBehavior(shutdown_behavior)));
+  }
+
+  // Tries to post |task| via |tracker_|. If |tracker_| approves the operation,
+  // |task| is added to |posted_tasks_|.
+  void PostTaskViaTracker(scoped_ptr<Task> task) {
+    tracker_.PostTask(
+        Bind(&TaskSchedulerTaskTrackerTest::PostTaskCallback, Unretained(this)),
+        std::move(task));
+  }
+
+  void RunNextPostedTaskViaTracker() {

[gab, 2016/03/09 21:53:25]

All methods but this one can move to "protected" I think (i.e. can only use in
this class and the test bodies).

[fdoray, 2016/03/15 17:28:09]

Done.

+    ASSERT_FALSE(posted_tasks_.empty());
+    tracker_.RunTask(posted_tasks_.front().get());
+    posted_tasks_.pop();
+  }
+
+  // Calls tracker_->Shutdown() on a new thread. When this returns, the
+  // Shutdown() method has been entered on the new thread, but it hasn't
+  // necessarily returned.
+  void CallShutdownAsync() {
+    DCHECK(!thread_calling_shutdown_.get());
+    thread_calling_shutdown_.reset(new ThreadCallingShutdown(&tracker_));
+    thread_calling_shutdown_->Start();
+    while (!tracker_.is_shutting_down_for_testing() &&
+           !tracker_.shutdown_completed()) {
+      PlatformThread::YieldCurrentThread();
+    }
+  }
+
+  void JoinAndExpectShutdownAsyncHasReturned() {

[gab, 2016/03/09 21:53:25]

JoinAndExpectAsyncShutdownCompleted() ?

[fdoray, 2016/03/15 17:28:09]

Done. Called it WaitForAsyncShutdownCompleted as you suggested in another of
your comments.

+    DCHECK(thread_calling_shutdown_.get());
+    thread_calling_shutdown_->Join();
+    EXPECT_TRUE(thread_calling_shutdown_->has_returned());
+    EXPECT_TRUE(tracker_.shutdown_completed());
+  }
+
+  void ExpectShutdownAsyncHasNotReturned() {

[gab, 2016/03/09 21:53:25]

VerifyAsyncShutdownInProgress()?

[fdoray, 2016/03/15 17:28:09]

Done.

+    DCHECK(thread_calling_shutdown_.get());
+    EXPECT_FALSE(thread_calling_shutdown_->has_returned());

[gab, 2016/03/09 21:53:25]

Add EXPECT_TRUE(tracker_.is_shutting_down_for_testing()) ?

[fdoray, 2016/03/15 17:28:09]

Done.

+    EXPECT_FALSE(tracker_.shutdown_completed());
+  }
+
+ protected:
+  TaskTracker tracker_;
+  size_t num_tasks_executed_;
+  std::queue<scoped_ptr<Task>> posted_tasks_;
+
+ private:
+  void PostTaskCallback(scoped_ptr<Task> task) {
+    posted_tasks_.push(std::move(task));
+  }
+
+  void RunTaskCallback() { ++num_tasks_executed_; }
+
+  scoped_ptr<ThreadCallingShutdown> thread_calling_shutdown_;
+
+  DISALLOW_COPY_AND_ASSIGN(TaskSchedulerTaskTrackerTest);
+};
+
+// A thread which calls
+// TaskSchedulerTaskTrackerTest::RunNextPostedTaskViaTracker() asynchronously.
+class ThreadRunningNextPostedTask : public SimpleThread {
+ public:
+  explicit ThreadRunningNextPostedTask(TaskSchedulerTaskTrackerTest* test)
+      : SimpleThread("ThreadRunningNextPostedTask"), test_(test) {}
+
+ private:
+  void Run() override { test_->RunNextPostedTaskViaTracker(); }
+
+  TaskSchedulerTaskTrackerTest* const test_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadRunningNextPostedTask);
+};
+
+}  // namespace
+
+// This test is repeated for each TaskShutownBehavior.
+TEST_P(TaskSchedulerTaskTrackerTest, PostAndRunBeforeShutdown) {

[robliao, 2016/03/09 22:31:46]

If the parametrized tests are like the ones here (no branches), I'm okay with
using them here.

Once they start having branches, we'll need to consider them on a case-by-case
basis.

[fdoray, 2016/03/15 17:28:09]

Every test is parameterized now.

+  scoped_ptr<Task> task_to_post(CreateTask(GetParam()));
+  const Task* task_to_post_raw = task_to_post.get();
+
+  // Post the task.
+  EXPECT_TRUE(posted_tasks_.empty());
+  PostTaskViaTracker(std::move(task_to_post));
+  ASSERT_FALSE(posted_tasks_.empty());
+  EXPECT_EQ(task_to_post_raw, posted_tasks_.front().get());
+
+  // Run the posted task.
+  EXPECT_EQ(0U, num_tasks_executed_);
+  RunNextPostedTaskViaTracker();
+  EXPECT_EQ(1U, num_tasks_executed_);
+
+  // Shutdown() shouldn't block.
+  tracker_.Shutdown();
+}
+
+TEST_F(TaskSchedulerTaskTrackerTest,
+       PostAndRunLongTaskBeforeShutdown_ContinueOnShutdown) {
+  // Post a CONTINUE_ON_SHUTDOWN task that will block until |event| is signaled.
+  EXPECT_TRUE(posted_tasks_.empty());
+  WaitableEvent event(false, false);
+  PostTaskViaTracker(make_scoped_ptr(
+      new Task(FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&event)),
+               TaskTraits().WithShutdownBehavior(
+                   TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN))));
+  ASSERT_FALSE(posted_tasks_.empty());

[gab, 2016/03/09 21:53:25]

Even better than verifying !empty() IMO here and elsewhere would be verifying
exact size().

[fdoray, 2016/03/15 17:28:09]

Done.

+
+  // Run the task asynchronouly.
+  ThreadRunningNextPostedTask thread(this);
+  thread.Start();
+
+  // Shutdown() shouldn't block.
+  tracker_.Shutdown();
+
+  // Unblock the task.
+  event.Signal();
+  thread.Join();
+}
+
+TEST_F(TaskSchedulerTaskTrackerTest,
+       PostAndRunLongTaskBeforeShutdown_SkipOnShutdown) {
+  // Post a SKIP_ON_SHUTDOWN task that will block until |event| is signaled.
+  EXPECT_TRUE(posted_tasks_.empty());
+  WaitableEvent event(false, false);
+  PostTaskViaTracker(make_scoped_ptr(
+      new Task(FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&event)),
+               TaskTraits().WithShutdownBehavior(
+                   TaskShutdownBehavior::SKIP_ON_SHUTDOWN))));
+  ASSERT_FALSE(posted_tasks_.empty());
+
+  // Run the task asynchronouly.
+  ThreadRunningNextPostedTask thread(this);
+  thread.Start();
+
+  // Shutdown() should block until the task has completed its execution.
+  CallShutdownAsync();
+  ExpectShutdownAsyncHasNotReturned();
+
+  // Unblock the task.
+  event.Signal();
+  thread.Join();
+
+  // Shutdown() should now return.
+  JoinAndExpectShutdownAsyncHasReturned();
+}
+
+TEST_F(TaskSchedulerTaskTrackerTest,
+       PostAndRunLongTaskBeforeShutdown_BlockShutdown) {
+  // Post a BLOCK_SHUTDOWN task that will block until |event| is signaled.
+  EXPECT_TRUE(posted_tasks_.empty());
+  WaitableEvent event(false, false);
+  PostTaskViaTracker(make_scoped_ptr(
+      new Task(FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&event)),
+               TaskTraits().WithShutdownBehavior(
+                   TaskShutdownBehavior::BLOCK_SHUTDOWN))));
+  ASSERT_FALSE(posted_tasks_.empty());
+
+  // Run the task asynchronouly.
+  ThreadRunningNextPostedTask thread(this);
+  thread.Start();
+
+  // Shutdown() should block until the task has completed its execution.
+  CallShutdownAsync();
+  ExpectShutdownAsyncHasNotReturned();
+
+  // Unblock the task.
+  event.Signal();
+  thread.Join();
+
+  // Shutdown() should now return.
+  JoinAndExpectShutdownAsyncHasReturned();
+}

[gab, 2016/03/09 21:53:25]

I'm surprised mixing TEST_F with TEST_P even works.

I still prefer merging the above 3 tests into 1 as:

TEST_P(TaskSchedulerTaskTrackerTest, PostAndRunLongTaskBeforeShutdown) {
  // Post a CONTINUE_ON_SHUTDOWN task that will block until |event| is signaled.
  EXPECT_TRUE(posted_tasks_.empty());
  WaitableEvent event(false, false);
  PostTaskViaTracker(make_scoped_ptr(
      new Task(FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&event)),
               TaskTraits().WithShutdownBehavior(GetParam()))));
  ASSERT_FALSE(posted_tasks_.empty());

  // Run the task asynchronouly.
  ThreadRunningNextPostedTask thread(this);
  thread.Start();

  if (GetParam() == TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN) {
    // Shutdown() shouldn't block with CONTINUE_ON_SHUTDOWN tasks in progress.
    tracker_.Shutdown();
  } else {
    // Shutdown() should block with any non CONTINUE_ON_SHUTDOWN task in
    // progress.
    CallShutdownAsync();
    ExpectShutdownAsyncHasNotReturned();
  }

  // Unblock the task.
  event.Signal();
  thread.Join();

  if (GetParam() != TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN) {
    // Shutdown() should now return.
    JoinAndExpectShutdownAsyncHasReturned();
  }
}


and even maybe for the sake of uniformizing, always call shutdown async and have
ThreadCallingShutdown fire an event when shutdown completes then this can
become:

TEST_P(TaskSchedulerTaskTrackerTest, PostAndRunLongTaskBeforeShutdown) {
  // Post a CONTINUE_ON_SHUTDOWN task that will block until |event| is signaled.
  EXPECT_TRUE(posted_tasks_.empty());
  WaitableEvent event(false, false);
  PostTaskViaTracker(make_scoped_ptr(
      new Task(FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&event)),
               TaskTraits().WithShutdownBehavior(GetParam()))));
  ASSERT_FALSE(posted_tasks_.empty());

  // Run the task asynchronouly.
  ThreadRunningNextPostedTask thread(this);
  thread.Start();

  // Initiate shutdown while the task is running.
  CallShutdownAsync();

  if (GetParam() == TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN) {
    // Shutdown should complete even with a CONTINUE_ON_SHUTDOWN in progress.
    WaitForShutdownCompleted();
  } else {
    // Shutdown should block with any non CONTINUE_ON_SHUTDOWN task in progress.
    ExpectShutdownAsyncHasNotReturned();
  }

  // Unblock the task.
  event.Signal();
  thread.Join();

  // Shutdown should complete in all cases now.
  JoinAndExpectShutdownAsyncHasReturned();
}


where WaitForShutdownCompleted() waits on a WaitableEvent(false, false) fired
right after Shutdown() returns -- and actually that event can replace the bool
that Shutdown() has returned via its IsSignaled() method :-)

[fdoray, 2016/03/15 17:28:09]

Done.

+
+TEST_F(TaskSchedulerTaskTrackerTest,

[gab, 2016/03/09 21:53:25]

Same thing as above for all remaining TEST_F's, try to fold all of these into
single parametrized tests, per your own argument : readability is improved when
the difference between each tests is clear and I find parametrized tests help
with this :-).

[fdoray, 2016/03/15 17:28:09]

Done.

+       PostBeforeShutdownRunDuringShutdown_ContinueOnShutdown) {
+  scoped_ptr<Task> task_to_post(
+      CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN));
+  const Task* task_to_post_raw = task_to_post.get();
+
+  // Post the task.
+  EXPECT_TRUE(posted_tasks_.empty());
+  PostTaskViaTracker(std::move(task_to_post));
+  ASSERT_FALSE(posted_tasks_.empty());
+  EXPECT_EQ(task_to_post_raw, posted_tasks_.front().get());
+
+  // Post a BLOCK_SHUTDOWN task just to block shutdown. Then, call Shutdown()
+  // asynchronously.
+  PostTaskViaTracker(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
+  CallShutdownAsync();
+  ExpectShutdownAsyncHasNotReturned();
+
+  // Try to run task posted at the beginning of this test. It should not work.
+  EXPECT_EQ(0U, num_tasks_executed_);
+  RunNextPostedTaskViaTracker();
+  EXPECT_EQ(0U, num_tasks_executed_);
+  ExpectShutdownAsyncHasNotReturned();
+
+  // Unblock shutdown by running the BLOCK_SHUTDOWN task.
+  RunNextPostedTaskViaTracker();
+  EXPECT_EQ(1U, num_tasks_executed_);
+  JoinAndExpectShutdownAsyncHasReturned();
+}
+
+TEST_F(TaskSchedulerTaskTrackerTest,
+       PostBeforeShutdownRunDuringShutdown_SkipOnShutdown) {
+  scoped_ptr<Task> task_to_post(
+      CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN));
+  const Task* task_to_post_raw = task_to_post.get();
+
+  // Post the task.
+  EXPECT_TRUE(posted_tasks_.empty());
+  PostTaskViaTracker(std::move(task_to_post));
+  ASSERT_FALSE(posted_tasks_.empty());
+  EXPECT_EQ(task_to_post_raw, posted_tasks_.front().get());
+
+  // Post a BLOCK_SHUTDOWN task just to block shutdown. Then, call Shutdown()
+  // asynchronously.
+  PostTaskViaTracker(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
+  CallShutdownAsync();
+  ExpectShutdownAsyncHasNotReturned();
+
+  // Try to run task posted at the beginning of this test. It should not work.
+  EXPECT_EQ(0U, num_tasks_executed_);
+  RunNextPostedTaskViaTracker();
+  EXPECT_EQ(0U, num_tasks_executed_);
+  ExpectShutdownAsyncHasNotReturned();
+
+  // Unblock shutdown by running the BLOCK_SHUTDOWN task.
+  RunNextPostedTaskViaTracker();
+  EXPECT_EQ(1U, num_tasks_executed_);
+  JoinAndExpectShutdownAsyncHasReturned();
+}
+
+TEST_F(TaskSchedulerTaskTrackerTest,
+       PostBeforeShutdownRunDuringShutdown_BlockShutdown) {
+  scoped_ptr<Task> task_to_post(
+      CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
+  const Task* task_to_post_raw = task_to_post.get();
+
+  // Post the task.
+  EXPECT_TRUE(posted_tasks_.empty());
+  PostTaskViaTracker(std::move(task_to_post));
+  ASSERT_FALSE(posted_tasks_.empty());
+  EXPECT_EQ(task_to_post_raw, posted_tasks_.front().get());
+
+  // Post a BLOCK_SHUTDOWN task just to block shutdown. Then, call Shutdown()
+  // asynchronously.
+  PostTaskViaTracker(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
+  CallShutdownAsync();
+  ExpectShutdownAsyncHasNotReturned();
+
+  // Try to run the first task posted in this test. It should run successfully.
+  EXPECT_EQ(0U, num_tasks_executed_);
+  RunNextPostedTaskViaTracker();
+  EXPECT_EQ(1U, num_tasks_executed_);
+  ExpectShutdownAsyncHasNotReturned();
+
+  // Unblock shutdown by running the remaining BLOCK_SHUTDOWN task.
+  RunNextPostedTaskViaTracker();
+  EXPECT_EQ(2U, num_tasks_executed_);
+  JoinAndExpectShutdownAsyncHasReturned();
+}
+
+TEST_F(TaskSchedulerTaskTrackerTest,
+       PostBeforeShutdownRunAfterShutdown_ContinueOnShutdown) {
+  scoped_ptr<Task> task_to_post(
+      CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN));
+  const Task* task_to_post_raw = task_to_post.get();
+
+  // Post the task.
+  EXPECT_TRUE(posted_tasks_.empty());
+  PostTaskViaTracker(std::move(task_to_post));
+  ASSERT_FALSE(posted_tasks_.empty());
+  ASSERT_EQ(task_to_post_raw, posted_tasks_.front().get());
+
+  // This should return immediately.
+  tracker_.Shutdown();
+
+  // The task shouldn't be allowed to run.
+  EXPECT_EQ(0U, num_tasks_executed_);
+  RunNextPostedTaskViaTracker();
+  EXPECT_EQ(0U, num_tasks_executed_);
+}
+
+TEST_F(TaskSchedulerTaskTrackerTest,
+       PostBeforeShutdownRunAfterShutdown_SkipOnShutdown) {
+  scoped_ptr<Task> task_to_post(
+      CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN));
+  const Task* task_to_post_raw = task_to_post.get();
+
+  // Post the task.
+  EXPECT_TRUE(posted_tasks_.empty());
+  PostTaskViaTracker(std::move(task_to_post));
+  ASSERT_FALSE(posted_tasks_.empty());
+  ASSERT_EQ(task_to_post_raw, posted_tasks_.front().get());
+
+  // This should return immediately.
+  tracker_.Shutdown();
+
+  // The task shouldn't be allowed to run.
+  EXPECT_EQ(0U, num_tasks_executed_);
+  RunNextPostedTaskViaTracker();
+  EXPECT_EQ(0U, num_tasks_executed_);
+}
+
+// It isn't possible to test running after shutdown a task that has been posted
+// before shutdown because Shutdown() won't return until the task has been
+// executed.
+
+TEST_F(TaskSchedulerTaskTrackerTest, RunAfterShutdown_BlockShutdown) {
+  tracker_.Shutdown();
+  EXPECT_DEBUG_DEATH(
+      tracker_.RunTask(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN).get()),
+      "");
+}
+
+TEST_F(TaskSchedulerTaskTrackerTest,
+       PostAndRunDuringShutdown_ContinueOnShutdown) {
+  // Post a BLOCK_SHUTDOWN task just to block shutdown. Then, call Shutdown()
+  // asynchronously.
+  EXPECT_TRUE(posted_tasks_.empty());
+  PostTaskViaTracker(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
+  EXPECT_EQ(1U, posted_tasks_.size());
+  CallShutdownAsync();
+  ExpectShutdownAsyncHasNotReturned();
+
+  // Try to post a CONTINUE_ON_SHUTDOWN task via |tracker_|. This should fail.
+  PostTaskViaTracker(CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN));
+  EXPECT_EQ(1U, posted_tasks_.size());
+
+  // Don't try to run the task, because it hasn't been posted successfully.
+
+  // Unblock shutdown by running the BLOCK_SHUTDOWN task.
+  ExpectShutdownAsyncHasNotReturned();
+  EXPECT_EQ(0U, num_tasks_executed_);
+  RunNextPostedTaskViaTracker();
+  EXPECT_EQ(1U, num_tasks_executed_);
+  JoinAndExpectShutdownAsyncHasReturned();
+}
+
+TEST_F(TaskSchedulerTaskTrackerTest, PostAndRunDuringShutdown_SkipOnShutdown) {
+  // Post a BLOCK_SHUTDOWN task just to block shutdown. Then, call Shutdown()
+  // asynchronously.
+  EXPECT_TRUE(posted_tasks_.empty());
+  PostTaskViaTracker(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
+  EXPECT_EQ(1U, posted_tasks_.size());
+  CallShutdownAsync();
+  ExpectShutdownAsyncHasNotReturned();
+
+  // Try to post a SKIP_ON_SHUTDOWN task via |tracker_|. This should fail.
+  PostTaskViaTracker(CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN));
+  EXPECT_EQ(1U, posted_tasks_.size());
+
+  // Don't try to run the task, because it hasn't been posted successfully.
+
+  // Unblock shutdown by running the BLOCK_SHUTDOWN task.
+  ExpectShutdownAsyncHasNotReturned();
+  EXPECT_EQ(0U, num_tasks_executed_);
+  RunNextPostedTaskViaTracker();
+  EXPECT_EQ(1U, num_tasks_executed_);
+  JoinAndExpectShutdownAsyncHasReturned();
+}
+
+TEST_F(TaskSchedulerTaskTrackerTest, PostAndRunDuringShutdown_BlockShutdown) {
+  // Post a BLOCK_SHUTDOWN task just to block shutdown. Then, call Shutdown()
+  // asynchronously.
+  PostTaskViaTracker(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
+  scoped_ptr<Task> block_shutdown_task = std::move(posted_tasks_.front());
+  posted_tasks_.pop();
+  CallShutdownAsync();
+  ExpectShutdownAsyncHasNotReturned();
+
+  // Try to post a BLOCK_SHUTDOWN task via |tracker_|. This should succeed.
+  EXPECT_TRUE(posted_tasks_.empty());
+  PostTaskViaTracker(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
+  EXPECT_EQ(1U, posted_tasks_.size());
+
+  // Try to run the task that was just posted. This should succeed.
+  EXPECT_EQ(0U, num_tasks_executed_);
+  RunNextPostedTaskViaTracker();
+  EXPECT_EQ(1U, num_tasks_executed_);
+
+  // Unblock shutdown by running the BLOCK_SHUTDOWN task posted at the beginning
+  // of the test.
+  ExpectShutdownAsyncHasNotReturned();
+  tracker_.RunTask(block_shutdown_task.get());
+  EXPECT_EQ(2U, num_tasks_executed_);
+  JoinAndExpectShutdownAsyncHasReturned();
+}
+
+// This test is repeated for each TaskShutownBehavior.
+TEST_P(TaskSchedulerTaskTrackerTest, PostAfterShutdown) {
+  // It is not possible to post a task after shutdown.
+  tracker_.Shutdown();
+  EXPECT_TRUE(posted_tasks_.empty());
+  PostTaskViaTracker(CreateTask(GetParam()));
+  EXPECT_TRUE(posted_tasks_.empty());
+}
+
+INSTANTIATE_TEST_CASE_P(
+    ContinueOnShutdown,
+    TaskSchedulerTaskTrackerTest,
+    ::testing::Values(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN));
+INSTANTIATE_TEST_CASE_P(
+    SkipOnShutdown,
+    TaskSchedulerTaskTrackerTest,
+    ::testing::Values(TaskShutdownBehavior::SKIP_ON_SHUTDOWN));
+INSTANTIATE_TEST_CASE_P(
+    BlockShutdown,
+    TaskSchedulerTaskTrackerTest,
+    ::testing::Values(TaskShutdownBehavior::BLOCK_SHUTDOWN));

[gab, 2016/03/09 21:53:26]

Oh nice, first time I see someone do it this way (3 instances, one per value --
I typically only use one test instance and have a list of values instead, e.g.:
https://code.google.com/p/chromium/codesearch#chromium/src/components/user_pr...),
but I find your approach cleaner so W00T!

[fdoray, 2016/03/15 17:28:09]

Acknowledged.

+
+}  // namespace internal
+}  // namespace base