Introduce ThreadTaskRunnerHandle::OverrideForTesting and TestMockTimeTaskRunner::ScopedContext.

base/threading/thread_task_runner_handle.h

Index: base/threading/thread_task_runner_handle.h
diff --git a/base/threading/thread_task_runner_handle.h b/base/threading/thread_task_runner_handle.h
index c8e58935f0977259349857bf91d71c63bf734567..8baf4544c9ed31e83ef2870c3364603d5f79b506 100644
--- a/base/threading/thread_task_runner_handle.h
+++ b/base/threading/thread_task_runner_handle.h
@@ -32,8 +32,30 @@ class BASE_EXPORT ThreadTaskRunnerHandle {
       scoped_refptr<SingleThreadTaskRunner> task_runner);
   ~ThreadTaskRunnerHandle();
 
+  // A ThreadTaskRunnerHandle::NestedForTesting is the same thing as a
+  // ThreadTaskRunnerHandle except that it allows overriding an existing
+  // ThreadTaskRunnerHandle in its scope. Nesting ThreadTaskRunnerHandles isn't
+  // generally desired but it can be useful in unit tests where multiple task
+  // runners are sharing the main thread for simplicity and determinism.
+  class BASE_EXPORT NestedForTesting {

[danakj, 2017/02/16 17:57:24]

Proposal to make the changes less invasive.

1) OverrideForTesting(scoped_refptr<STTR>) method here on
ThreadTaskRunnerHandle. Make that the only method added to TTRH.

2) It returns a unique_ptr<ThreadTaskRunnerHandle::Restore> which in its
destructor calls OverrideForTesting to put back the last thing.

3) TTRH doesn't need to change its own implementation at all.

Would that work?

[gab, 2017/02/16 21:03:36]

That's what I wanted to do at first, but then hit two problems :
 1) The TLS is holding a TTRH, not a STR.
 2) The Restore class ends up looking essentially like NestedForTesting, at
which point it feels silly to have a static method that is essentially merely
constructing that class and handing it to you in a unique_ptr (you might as well
have it directly allocated on the stack) -- and iterating some more to simplify
having just one piece of TLS you get to NestedForTesting owning TLS like I
did...


But... :)

I forgot about that at first and gave it a second shot and had a realization
that since we only need Restore for its destructor (its constructor is merely to
store state for its destructor), we can package all of that in a
ScopedClosureRunner and then it becomes very neat :)!

And added tests this time around per the complexity rising above a trivial
scoper.

+   public:
+    explicit NestedForTesting(
+        scoped_refptr<SingleThreadTaskRunner> task_runner);
+    ~NestedForTesting();
+
+   private:
+    friend class ThreadTaskRunnerHandle;
+
+    scoped_refptr<SingleThreadTaskRunner> task_runner_;
+    const NestedForTesting* const previous_handle_;
+
+    DISALLOW_COPY_AND_ASSIGN(NestedForTesting);
+  };
+
  private:
-  scoped_refptr<SingleThreadTaskRunner> task_runner_;
+  // The impl uses NestedForTesting to avoid code duplication but this is the
+  // only allowed non-test usage.
+  std::unique_ptr<NestedForTesting> handle_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadTaskRunnerHandle);
 };