Run ScopedTaskScheduler tasks synchronously.

base/test/scoped_task_scheduler.h

 // 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.
 
 #ifndef BASE_TEST_SCOPED_TASK_SCHEDULER_H_
 #define BASE_TEST_SCOPED_TASK_SCHEDULER_H_
 
 #include "base/macros.h"
+#include "base/threading/thread_checker.h"
 
 namespace base {
 
 class TaskScheduler;
 
 namespace test {
 
-// Initializes a TaskScheduler and allows usage of the
-// base/task_scheduler/post_task.h API within its scope.
+// Allows usage of the base/task_scheduler/post_task.h API within its scope.
+//
+// To run pending tasks synchronously, call RunLoop::Run/RunUntilIdle() on the
+// thread where the ScopedTaskScheduler lives. The destructor of runs remaining

[gab, 2016/12/08 20:15:45]

rm "of"

[fdoray, 2016/12/09 16:26:41]

Done.

+// BLOCK_SHUTDOWN tasks synchronously.
+//
+// Example usage:
+//
+// base::test::ScopedTaskScheduler scoped_task_scheduler;

[robliao, 2016/12/09 01:32:54]

Nit: It might be clearer to have a leading section explain what the code does
below instead of adding those notes in the comments.

e.g.

In the following snippet, RunUntilIdle() returns after "A" is run.

...

In this snippet, run_loop.Run() returns after running "B" and "RunLoop::Quit".
"C" is not run and "D" is run since it's BLOCK_SHUTDOWN.

[fdoray, 2016/12/09 16:26:41]

Done.

+// base::PostTask(FROM_HERE, base::Bind(&A));
+// base::RunLoop::RunUntilIdle(); // Returns after running A.
+//
+// base::RunLoop run_loop;
+// base::PostTask(FROM_HERE, base::Bind(&B));
+// base::PostTask(FROM_HERE, base::Bind(&RunLoop::Quit, &run_loop));
+// base::PostTask(FROM_HERE, base::Bind(&C));
+// base::PostTaskWithTraits(
+//     base::TaskTraits().WithShutdownBehavior(
+//         base::TaskShutdownBehavior::BLOCK_SHUTDOWN),
+//     base::Bind(&D));
+// run_loop.Run();  // Returns after running B and RunLoop::Quit.
+//
+// D runs at the end of this scope because it is BLOCK_SHUTDOWN.
 class ScopedTaskScheduler {
  public:
-  // Initializes a TaskScheduler with default arguments.
+  enum Options {
+    DEFAULT = 0x0,

[robliao, 2016/12/09 01:32:54]

Is this going to be a future set of flags? If not, using decimal should be fine.

[fdoray, 2016/12/09 16:26:41]

Removed.

+
+    // Run TaskScheduler on a MessageLoopForUI instead of a MessageLoopForIO.
+    // TaskScheduler tasks can't use FileDescriptorWatcher with this option.
+    UI_MAIN_LOOP = 0x1,
+  };
+
+  // Registers a TaskScheduler.
   ScopedTaskScheduler();
+  ScopedTaskScheduler(Options options);
 
-  // Waits until all TaskScheduler tasks blocking shutdown complete their
-  // execution (see TaskShutdownBehavior). Then, joins all TaskScheduler threads
-  // and deletes the TaskScheduler.
-  //
-  // Note that joining TaskScheduler threads may involve waiting for
-  // CONTINUE_ON_SHUTDOWN tasks to complete their execution. Normally, in
-  // production, the process exits without joining TaskScheduler threads.
+  // Runs all pending BLOCK_SHUTDOWN tasks and unregisters the TaskScheduler.
   ~ScopedTaskScheduler();
 
  private:
   const TaskScheduler* task_scheduler_ = nullptr;
+  ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedTaskScheduler);
 };
 
 }  // namespace test
 }  // namespace base
 
 #endif  // BASE_TEST_SCOPED_TASK_SCHEDULER_H_