[Reland] Use the SequenceManager in ScopedTaskEnvironment

A reland of https://crrev.com/c/1324391

This is necessary because we want content::TestBrowserThreadBundle to
own a BrowserUIThreadScheduler, but that also owns a ScopedTaskEnvironment
and you can't have two SequenceManagers on the same thread.

This patch allows ScopedTaskEnvironment to optionally work with an
externally owned SequenceManager solving the problem.

This implements https://docs.google.com/document/d/1y08C6JQ9Yta3EQXzwIqqIIKHq9500WV6CWFZzZfDx7I/edit?usp=drivesdk,

We now have the ability to mock time on the UI thread.

TBR=asvitkine@chromium.org,miu@chromium.org,gab@chromium.org,fdoray@chromium.org

Bug: 863341, 891670, 708584
Change-Id: Ia4409b885deb9935e6e5b6d99f4598f164d350db
Reviewed-on: https://chromium-review.googlesource.com/c/1354919Reviewed-by: Alex Clarke <alexclarke@chromium.org>
Commit-Queue: Alex Clarke <alexclarke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#612122}

base/message_loop/message_pump_mac.mm

@@ -181,6 +181,7 @@ void MessagePumpCFRunLoopBase::Run(Delegate* delegate) {
   Delegate* last_delegate = delegate_;
   SetDelegate(delegate);
 
+  ScheduleWork();
   DoRun(delegate);
 
   // Restore the previous state of the object.

base/task/sequence_manager/thread_controller_with_message_pump_impl.cc

@@ -268,7 +268,7 @@ bool ThreadControllerWithMessagePumpImpl::DoWorkImpl(
   DCHECK_GE(do_work_delay, TimeDelta());
   // Schedule a continuation.
   // TODO(altimin, gab): Make this more efficient by merging DoWork
-  // and DoDelayedWork and allowing returing base::TimeTicks() when we have
+  // and DoDelayedWork and allowing returning base::TimeTicks() when we have
   // immediate work.
   if (do_work_delay.is_zero()) {
     // Need to run new work immediately, but due to the contract of DoWork we
@@ -310,8 +310,12 @@ bool ThreadControllerWithMessagePumpImpl::DoIdleWork() {
   }
 #endif  // defined(OS_WIN)
 
-  if (main_thread_only().task_source->OnSystemIdle())
-    return true;  // Pretend we have done work to ensure DoWork is called.
+  if (main_thread_only().task_source->OnSystemIdle()) {
+    // The OnSystemIdle() callback resulted in more immediate work, so schedule
+    // a DoWork callback.
+    pump_->ScheduleWork();
+    return false;
+  }
 
   // RunLoop::Delegate knows whether we called Run() or RunUntilIdle().
   if (ShouldQuitWhenIdle())

base/test/scoped_task_environment.h

@@ -9,19 +9,14 @@
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task/lazy_task_runner.h"
+#include "base/task/sequence_manager/sequence_manager.h"
 #include "build/build_config.h"
 
 namespace base {
 
-namespace internal {
-class ScopedSetSequenceLocalStorageMapForCurrentThread;
-class SequenceLocalStorageMap;
-}  // namespace internal
 
 class FileDescriptorWatcher;
-class MessageLoop;
 class TaskScheduler;
-class TestMockTimeTaskRunner;
 class TickClock;
 
 namespace test {
@@ -76,6 +71,11 @@ class ScopedTaskEnvironment {
     MOCK_TIME,
     // The main thread pumps UI messages.
     UI,
+    // The main thread pumps UI messages and uses a mock clock for delayed tasks
+    // (controllable via FastForward*() methods).
+    // TODO(gab@): Enable mock time on all threads and make MOCK_TIME
+    // configurable independent of MainThreadType.
+    UI_MOCK_TIME,
     // The main thread pumps asynchronous IO messages and supports the
     // FileDescriptorWatcher API on POSIX.
     IO,
@@ -94,6 +94,13 @@ class ScopedTaskEnvironment {
       MainThreadType main_thread_type = MainThreadType::DEFAULT,
       ExecutionMode execution_control_mode = ExecutionMode::ASYNC);
 
+  // Constructs a ScopedTaskEnvironment using a preexisting |sequence_manager|.
+  // |sequence_manager| must outlive this ScopedTaskEnvironment.
+  ScopedTaskEnvironment(
+      sequence_manager::SequenceManager* sequence_manager,
+      MainThreadType main_thread_type = MainThreadType::DEFAULT,
+      ExecutionMode execution_control_mode = ExecutionMode::ASYNC);
+
   // Waits until no undelayed TaskScheduler tasks remain. Then, unregisters the
   // TaskScheduler and the (Thread|Sequenced)TaskRunnerHandle.
   ~ScopedTaskEnvironment();
@@ -155,24 +162,25 @@ class ScopedTaskEnvironment {
   TimeDelta NextMainThreadPendingTaskDelay() const;
 
  private:
+  class MockTimeDomain;
   class TestTaskTracker;
 
+  ScopedTaskEnvironment(
+      std::unique_ptr<sequence_manager::SequenceManager> owned_sequence_manager,
+      sequence_manager::SequenceManager* sequence_manager,
+      MainThreadType main_thread_type,
+      ExecutionMode execution_control_mode);
+
+  scoped_refptr<sequence_manager::TaskQueue> CreateDefaultTaskQueue();
+
   const ExecutionMode execution_control_mode_;
 
-  // Exactly one of these will be non-null to provide the task environment on
-  // the main thread. Users of this class should NOT rely on the presence of a
-  // MessageLoop beyond (Thread|Sequenced)TaskRunnerHandle and RunLoop as
-  // the backing implementation of each MainThreadType may change over time.
-  const std::unique_ptr<MessageLoop> message_loop_;
-  const scoped_refptr<TestMockTimeTaskRunner> mock_time_task_runner_;
-
-  // Non-null in MOCK_TIME, where an explicit SequenceLocalStorageMap needs to
-  // be provided. TODO(gab): This can be removed once mock time support is added
-  // to MessageLoop directly.
-  const std::unique_ptr<internal::SequenceLocalStorageMap> slsm_for_mock_time_;
-  const std::unique_ptr<
-      internal::ScopedSetSequenceLocalStorageMapForCurrentThread>
-      slsm_registration_for_mock_time_;
+  const std::unique_ptr<MockTimeDomain> mock_time_domain_;
+  const std::unique_ptr<sequence_manager::SequenceManager>
+      owned_sequence_manager_;
+  sequence_manager::SequenceManager* const sequence_manager_;
+
+  scoped_refptr<sequence_manager::TaskQueue> task_queue_;
 
 #if defined(OS_POSIX) || defined(OS_FUCHSIA)
   // Enables the FileDescriptorWatcher API iff running a MainThreadType::IO.

base/test/scoped_task_environment_unittest.cc

@@ -358,6 +358,10 @@ INSTANTIATE_TEST_CASE_P(
     MainThreadMockTime,
     ScopedTaskEnvironmentTest,
     ::testing::Values(ScopedTaskEnvironment::MainThreadType::MOCK_TIME));
+INSTANTIATE_TEST_CASE_P(
+    MainThreadUiMockTime,
+    ScopedTaskEnvironmentTest,
+    ::testing::Values(ScopedTaskEnvironment::MainThreadType::UI_MOCK_TIME));
 INSTANTIATE_TEST_CASE_P(
     MainThreadUI,
     ScopedTaskEnvironmentTest,
@@ -573,6 +577,10 @@ INSTANTIATE_TEST_CASE_P(
     MainThreadMockTime,
     ScopedTaskEnvironmentMockedTime,
     ::testing::Values(ScopedTaskEnvironment::MainThreadType::MOCK_TIME));
+INSTANTIATE_TEST_CASE_P(
+    MainThreadUiMockTime,
+    ScopedTaskEnvironmentMockedTime,
+    ::testing::Values(ScopedTaskEnvironment::MainThreadType::UI_MOCK_TIME));
 
 }  // namespace test
 }  // namespace base

content/browser/renderer_host/render_widget_host_view_mac_unittest.mm

@@ -1304,7 +1304,7 @@ TEST_F(RenderWidgetHostViewMacTest, TimerBasedPhaseInfo) {
   // event gets dispatched.
   base::RunLoop run_loop;
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-      FROM_HERE, run_loop.QuitClosure(),
+      FROM_HERE, run_loop.QuitWhenIdleClosure(),
       base::TimeDelta::FromMilliseconds(100));
   run_loop.Run();
 

content/renderer/media/stream/webmediaplayer_ms_unittest.cc

@@ -1114,6 +1114,9 @@ TEST_P(WebMediaPlayerMSTest, RotationChange) {
               CheckSizeChanged(gfx::Size(kStandardWidth, kStandardHeight)));
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
+  // The exact ordering of delayed vs non-delayed tasks is not defined.
+  // Make sure we run all non-delayed tasks before testing state.
+  base::RunLoop().RunUntilIdle();
   blink::WebSize natural_size = player_->NaturalSize();
   // Check that height and width are flipped.
   EXPECT_EQ(kStandardHeight, natural_size.width);
@@ -1132,6 +1135,7 @@ TEST_P(WebMediaPlayerMSTest, RotationChange) {
   }
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
+  base::RunLoop().RunUntilIdle();
   natural_size = player_->NaturalSize();
   EXPECT_EQ(kStandardHeight, natural_size.height);
   EXPECT_EQ(kStandardWidth, natural_size.width);
@@ -1172,6 +1176,9 @@ TEST_P(WebMediaPlayerMSTest, OpacityChange) {
               CheckSizeChanged(gfx::Size(kStandardWidth, kStandardHeight)));
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
+  // The exact ordering of delayed vs non-delayed tasks is not defined.
+  // Make sure we run all non-delayed tasks before testing state.
+  base::RunLoop().RunUntilIdle();
   if (!enable_surface_layer_for_video_) {
     ASSERT_TRUE(layer_ != nullptr);
     EXPECT_TRUE(layer_->contents_opaque());
@@ -1187,6 +1194,7 @@ TEST_P(WebMediaPlayerMSTest, OpacityChange) {
   }
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
+  base::RunLoop().RunUntilIdle();
   if (!enable_surface_layer_for_video_) {
     EXPECT_FALSE(layer_->contents_opaque());
   }
@@ -1201,6 +1209,7 @@ TEST_P(WebMediaPlayerMSTest, OpacityChange) {
   }
   message_loop_controller_.RunAndWaitForStatus(
       media::PipelineStatus::PIPELINE_OK);
+  base::RunLoop().RunUntilIdle();
   if (!enable_surface_layer_for_video_)
     EXPECT_TRUE(layer_->contents_opaque());