Introduce ThreadTaskRunnerHandle::OverrideForTesting and TestMockTimeTaskRunner::ScopedContext.

base/threading/thread_task_runner_handle.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_THREADING_THREAD_TASK_RUNNER_HANDLE_H_
 #define BASE_THREADING_THREAD_TASK_RUNNER_HANDLE_H_
 
 #include "base/base_export.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 14 matching lines @@
   // Returns true if the SingleThreadTaskRunner is already created for
   // the current thread.
   static bool IsSet();
 
   // Binds |task_runner| to the current thread. |task_runner| must belong
   // to the current thread for this to succeed.
   explicit 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);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_THREAD_TASK_RUNNER_HANDLE_H_