Remove MessageLoop in //base

MessageLoop is going away. Also had to fix a lot of includes as a bunch
of files were not directly including their dependencies.

Bug: 891670
Change-Id: I1b962b9513596b399175498278ad526fba2240f6
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1807504
Commit-Queue: Carlos Caballero <carlscab@google.com>
Reviewed-by: Gabriel Charette <gab@chromium.org>
Cr-Commit-Position: refs/heads/master@{#699658}

base/message_loop/message_loop.h

@@ -23,10 +23,6 @@
 
 namespace base {
 
-namespace internal {
-class MessageLoopThreadDelegate;
-}  // namespace internal
-
 class MessageLoopImpl;
 class MessagePump;
 class TaskObserver;
@@ -160,7 +156,6 @@ class BASE_EXPORT MessageLoop {
   friend class MessageLoopTypedTest;
   friend class ScheduleWorkTest;
   friend class Thread;
-  friend class internal::MessageLoopThreadDelegate;
   friend class sequence_manager::internal::SequenceManagerImpl;
   FRIEND_TEST_ALL_PREFIXES(MessageLoopTest, DeleteUnboundLoop);
 

base/message_loop/message_pump_perftest.cc

@@ -9,7 +9,6 @@
 #include "base/bind_helpers.h"
 #include "base/format_macros.h"
 #include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_current.h"
 #include "base/message_loop/message_pump_type.h"
 #include "base/single_thread_task_runner.h"
@@ -98,12 +97,7 @@ class ScheduleWorkTest : public testing::Test {
       target_.reset(new Thread("test"));
 
       Thread::Options options(target_type, 0u);
-
-      std::unique_ptr<MessageLoop> message_loop =
-          MessageLoop::CreateUnbound(target_type);
-      message_loop_ = message_loop.get();
-      options.delegate =
-          new internal::MessageLoopThreadDelegate(std::move(message_loop));
+      options.message_pump_type = target_type;
       target_->StartWithOptions(options);
 
       // Without this, it's possible for the scheduling threads to start and run
@@ -203,7 +197,6 @@ class ScheduleWorkTest : public testing::Test {
 
  private:
   std::unique_ptr<Thread> target_;
-  MessageLoop* message_loop_;
 #if defined(OS_ANDROID)
   std::unique_ptr<JavaHandlerThreadForTest> java_thread_;
 #endif

base/test/trace_to_file.cc

@@ -9,8 +9,8 @@
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/test/task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_buffer.h"
 #include "base/trace_event/trace_log.h"
@@ -96,10 +96,10 @@ void TraceToFile::EndTracingIfNeeded() {
   buffer.SetOutputCallback(
       BindRepeating(&TraceToFile::TraceOutputCallback, Unretained(this)));
 
-  // In tests we might not have a MessageLoop, create one if needed.
-  std::unique_ptr<MessageLoop> message_loop;
+  // In tests we might not have a TaskEnvironment, create one if needed.
+  std::unique_ptr<SingleThreadTaskEnvironment> task_environment;
   if (!ThreadTaskRunnerHandle::IsSet())
-    message_loop = std::make_unique<MessageLoop>();
+    task_environment = std::make_unique<SingleThreadTaskEnvironment>();
 
   RunLoop run_loop;
   trace_event::TraceLog::GetInstance()->Flush(BindRepeating(

base/threading/thread.cc

@@ -4,14 +4,21 @@
 
 #include "base/threading/thread.h"
 
+#include <type_traits>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/memory/scoped_refptr.h"
+#include "base/message_loop/message_loop_current.h"
+#include "base/message_loop/message_pump.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/task/sequence_manager/sequence_manager_impl.h"
+#include "base/task/sequence_manager/task_queue.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/thread_id_name_manager.h"
 #include "base/threading/thread_local.h"
@@ -38,6 +45,56 @@ namespace {
 base::LazyInstance<base::ThreadLocalBoolean>::Leaky lazy_tls_bool =
     LAZY_INSTANCE_INITIALIZER;
 
+class SequenceManagerThreadDelegate : public Thread::Delegate {
+ public:
+  explicit SequenceManagerThreadDelegate(
+      MessagePumpType message_pump_type,
+      OnceCallback<std::unique_ptr<MessagePump>()> message_pump_factory)
+      : sequence_manager_(
+            sequence_manager::internal::SequenceManagerImpl::CreateUnbound(
+                sequence_manager::SequenceManager::Settings::Builder()
+                    .SetMessagePumpType(message_pump_type)
+                    .Build())),
+        default_task_queue_(sequence_manager_->CreateTaskQueue(
+            sequence_manager::TaskQueue::Spec("default_tq"))),
+        message_pump_factory_(std::move(message_pump_factory)) {
+    sequence_manager_->SetDefaultTaskRunner(default_task_queue_->task_runner());
+  }
+
+  ~SequenceManagerThreadDelegate() override = default;
+
+  scoped_refptr<SingleThreadTaskRunner> GetDefaultTaskRunner() override {
+    // Surprisingly this might not be default_task_queue_->task_runner() which
+    // we set in the constructor. The Thread::Init() method could create a
+    // SequenceManager on top of the current one and call
+    // SequenceManager::SetDefaultTaskRunner which would propagate the new
+    // TaskRunner down to our SequenceManager. Turns out, code actually relies
+    // on this and somehow relies on
+    // SequenceManagerThreadDelegate::GetDefaultTaskRunner returning this new
+    // TaskRunner. So instead of returning default_task_queue_->task_runner() we
+    // need to query the SequenceManager for it.
+    // The underlying problem here is that Subclasses of Thread can do crazy
+    // stuff in Init() but they are not really in control of what happens in the
+    // Thread::Delegate, as this is passed in on calling StartWithOptions which
+    // could happen far away from where the Thread is created. We should
+    // consider getting rid of StartWithOptions, and pass them as a constructor
+    // argument instead.
+    return sequence_manager_->GetTaskRunner();
+  }
+
+  void BindToCurrentThread(TimerSlack timer_slack) override {
+    sequence_manager_->BindToMessagePump(
+        std::move(message_pump_factory_).Run());
+    sequence_manager_->SetTimerSlack(timer_slack);
+  }
+
+ private:
+  std::unique_ptr<sequence_manager::internal::SequenceManagerImpl>
+      sequence_manager_;
+  scoped_refptr<sequence_manager::TaskQueue> default_task_queue_;
+  OnceCallback<std::unique_ptr<MessagePump>()> message_pump_factory_;
+};
+
 }  // namespace
 
 Thread::Options::Options() = default;
@@ -100,11 +157,13 @@ bool Thread::StartWithOptions(const Options& options) {
     DCHECK(!options.message_pump_factory);
     delegate_ = WrapUnique(options.delegate);
   } else if (options.message_pump_factory) {
-    delegate_ = std::make_unique<internal::MessageLoopThreadDelegate>(
-        MessageLoop::CreateUnbound(options.message_pump_factory.Run()));
+    delegate_ = std::make_unique<SequenceManagerThreadDelegate>(
+        MessagePumpType::CUSTOM, options.message_pump_factory);
   } else {
-    delegate_ = std::make_unique<internal::MessageLoopThreadDelegate>(
-        MessageLoop::CreateUnbound(options.message_pump_type));
+    delegate_ = std::make_unique<SequenceManagerThreadDelegate>(
+        options.message_pump_type,
+        BindOnce([](MessagePumpType type) { return MessagePump::Create(type); },
+                 options.message_pump_type));
   }
 
   start_event_.Reset();
@@ -291,9 +350,10 @@ void Thread::ThreadMain() {
 #if defined(OS_WIN)
   std::unique_ptr<win::ScopedCOMInitializer> com_initializer;
   if (com_status_ != NONE) {
-    com_initializer.reset((com_status_ == STA) ?
-        new win::ScopedCOMInitializer() :
-        new win::ScopedCOMInitializer(win::ScopedCOMInitializer::kMTA));
+    com_initializer.reset(
+        (com_status_ == STA)
+            ? new win::ScopedCOMInitializer()
+            : new win::ScopedCOMInitializer(win::ScopedCOMInitializer::kMTA));
   }
 #endif
 
@@ -337,24 +397,4 @@ void Thread::ThreadQuitHelper() {
   SetThreadWasQuitProperly(true);
 }
 
-namespace internal {
-
-MessageLoopThreadDelegate::MessageLoopThreadDelegate(
-    std::unique_ptr<MessageLoop> message_loop)
-    : message_loop_(std::move(message_loop)) {}
-
-MessageLoopThreadDelegate::~MessageLoopThreadDelegate() {}
-
-scoped_refptr<SingleThreadTaskRunner>
-MessageLoopThreadDelegate::GetDefaultTaskRunner() {
-  return message_loop_->task_runner();
-}
-
-void MessageLoopThreadDelegate::BindToCurrentThread(TimerSlack timer_slack) {
-  message_loop_->BindToCurrentThread();
-  message_loop_->SetTimerSlack(timer_slack);
-}
-
-}  // namespace internal
-
 }  // namespace base

base/threading/thread.h

@@ -13,8 +13,6 @@
 #include "base/base_export.h"
 #include "base/callback.h"
 #include "base/macros.h"
-#include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_current.h"
 #include "base/message_loop/message_pump_type.h"
 #include "base/message_loop/timer_slack.h"
 #include "base/sequence_checker.h"
@@ -331,24 +329,6 @@ class BASE_EXPORT Thread : PlatformThread::Delegate {
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
-namespace internal {
-
-class BASE_EXPORT MessageLoopThreadDelegate : public Thread::Delegate {
- public:
-  explicit MessageLoopThreadDelegate(std::unique_ptr<MessageLoop> message_loop);
-
-  ~MessageLoopThreadDelegate() override;
-
-  // Thread::Delegate:
-  scoped_refptr<SingleThreadTaskRunner> GetDefaultTaskRunner() override;
-  void BindToCurrentThread(TimerSlack timer_slack) override;
-
- private:
-  std::unique_ptr<MessageLoop> message_loop_;
-};
-
-}  // namespace internal
-
 }  // namespace base
 
 #endif  // BASE_THREADING_THREAD_H_