Lazily initialize MessageLoop for faster thread startup

base/message_loop/message_loop.cc

 // Copyright 2013 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.
 
 #include "base/message_loop/message_loop.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 82 matching lines @@
 #elif defined(OS_POSIX)
 typedef MessagePumpLibevent MessagePumpForIO;
 #endif
 
 #if !defined(OS_NACL_SFI)
 MessagePumpForIO* ToPumpIO(MessagePump* pump) {
   return static_cast<MessagePumpForIO*>(pump);
 }
 #endif  // !defined(OS_NACL_SFI)
 
+MessageLoop::Type GetMessageLoopType(const MessageLoop::InitOptions& options) {
+  if (options.message_pump_factory.is_null())

[danakj, 2015/04/24 20:54:39]

this was a little bit of work to parse in my head can you maybe use a temp to
make this read a little easier?

bool have_message_pump_factory = !options.message_pump_factory.is_null();
if (have_message_pump_factory)
  return CUSTOM;
return options.type;

[kinuko, 2015/04/27 16:36:04]

(This code is now gone)

+    return options.message_loop_type;
+  return MessageLoop::TYPE_CUSTOM;
+}
+
 }  // namespace
 
 //------------------------------------------------------------------------------
 
+MessageLoop::InitOptions::InitOptions()
+    : message_loop_type(MessageLoop::TYPE_DEFAULT),
+      timer_slack(TIMER_SLACK_NONE) {
+}
+
+MessageLoop::InitOptions::~InitOptions() {
+}
+
+//------------------------------------------------------------------------------
+
 MessageLoop::TaskObserver::TaskObserver() {
 }
 
 MessageLoop::TaskObserver::~TaskObserver() {
 }
 
 MessageLoop::DestructionObserver::~DestructionObserver() {
 }
 
 //------------------------------------------------------------------------------
 
+MessageLoop::MessageLoop(const InitOptions& options)
+    : type_(GetMessageLoopType(options)),
+#if defined(OS_WIN)
+      pending_high_res_tasks_(0),
+      in_high_res_mode_(false),
+#endif
+      nestable_tasks_allowed_(true),
+#if defined(OS_WIN)
+      os_modal_loop_(false),
+#endif  // OS_WIN
+      init_options_(new InitOptions(options)),

[Nico, 2015/04/24 21:31:15]

Maybe this should be passed in as scoped_ptr? That would save a copy.

[kinuko, 2015/04/27 16:36:04]

(This struct is now gone)

+      message_histogram_(NULL),
+      run_loop_(NULL),
+      incoming_task_queue_(new internal::IncomingTaskQueue(this)),
+      message_loop_proxy_(
+          new internal::MessageLoopProxyImpl(incoming_task_queue_)) {
+}
+
 MessageLoop::MessageLoop(Type type)
     : type_(type),
 #if defined(OS_WIN)
       pending_high_res_tasks_(0),
       in_high_res_mode_(false),
 #endif
       nestable_tasks_allowed_(true),
 #if defined(OS_WIN)
       os_modal_loop_(false),
 #endif  // OS_WIN
       message_histogram_(NULL),
-      run_loop_(NULL) {
+      run_loop_(NULL),
+      incoming_task_queue_(new internal::IncomingTaskQueue(this)),
+      message_loop_proxy_(
+          new internal::MessageLoopProxyImpl(incoming_task_queue_)) {
   Init();

[danakj, 2015/04/24 20:54:39]

it'd be nice if these other constructors set up an InitOptions and so just
delegated work to the first constructor.

[Nico, 2015/04/24 21:31:15]

It feels strange that one constructor doesn't create MessagePump while the other
two do. The interface should probably be uniform in all modes. Maybe the other
two constructors could delegate to the "main" constructor with an appropriate
InitOptions object?

[kinuko, 2015/04/27 16:36:04]

Done.

-
   pump_ = CreateMessagePumpForType(type).Pass();
 }
 
 MessageLoop::MessageLoop(scoped_ptr<MessagePump> pump)
     : pump_(pump.Pass()),
       type_(TYPE_CUSTOM),
 #if defined(OS_WIN)
       pending_high_res_tasks_(0),
       in_high_res_mode_(false),
 #endif
       nestable_tasks_allowed_(true),
 #if defined(OS_WIN)
       os_modal_loop_(false),
 #endif  // OS_WIN
       message_histogram_(NULL),
-      run_loop_(NULL) {
+      run_loop_(NULL),
+      incoming_task_queue_(new internal::IncomingTaskQueue(this)),
+      message_loop_proxy_(
+          new internal::MessageLoopProxyImpl(incoming_task_queue_)) {
   DCHECK(pump_.get());
   Init();
 }
 
 MessageLoop::~MessageLoop() {
+  if (init_options_) {
+    // This message loop is destructed before we call Init.

[danakj, 2015/04/24 20:54:39]

Why do you do this early out path, what are you trying to avoid? You end up
avoiding things like the observers.

[kinuko, 2015/04/27 16:36:04]

The code below is not really meaningful when this loop is destructed before it's
bound to a thread.  We could just go through the same code for such cases too, I
removed this early path.

+    DCHECK(current() == NULL);
+    DCHECK(incoming_task_queue_->empty());
+    DCHECK(!pump_);
+    DCHECK(!destruction_observers_.might_have_observers());
+    incoming_task_queue_->WillDestroyCurrentMessageLoop();
+    return;
+  }
+
   DCHECK_EQ(this, current());
 
   // iOS just attaches to the loop, it doesn't Run it.
   // TODO(stuartmorgan): Consider wiring up a Detach().
 #if !defined(OS_IOS)
   DCHECK(!run_loop_);
 #endif
 
 #if defined(OS_WIN)
   if (in_high_res_mode_)
@@ skipping 90 matching lines @@
 
 #if defined(OS_ANDROID)
   if (type == MessageLoop::TYPE_JAVA)
     return scoped_ptr<MessagePump>(new MessagePumpForUI());
 #endif
 
   DCHECK_EQ(MessageLoop::TYPE_DEFAULT, type);
   return MESSAGE_PUMP_DEFAULT;
 }
 
+void MessageLoop::Init() {
+  if (init_options_) {
+    DCHECK(!pump_);
+    if (!init_options_->message_pump_factory.is_null())
+      pump_ = init_options_->message_pump_factory.Run();
+    else
+      pump_ = CreateMessagePumpForType(init_options_->message_loop_type);
+    SetTimerSlack(init_options_->timer_slack);
+    init_options_.reset();
+  }
+
+  DCHECK(!current()) << "should only have one message loop per thread";
+  lazy_tls_ptr.Pointer()->Set(this);
+
+  incoming_task_queue_->StartScheduling();
+  message_loop_proxy_->Init();
+  thread_task_runner_handle_.reset(
+      new ThreadTaskRunnerHandle(message_loop_proxy_));
+}
+
 void MessageLoop::AddDestructionObserver(
     DestructionObserver* destruction_observer) {
   DCHECK_EQ(this, current());
   destruction_observers_.AddObserver(destruction_observer);
 }
 
 void MessageLoop::RemoveDestructionObserver(
     DestructionObserver* destruction_observer) {
   DCHECK_EQ(this, current());
   destruction_observers_.RemoveObserver(destruction_observer);
@@ skipping 19 matching lines @@
 }
 
 void MessageLoop::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
     const Closure& task,
     TimeDelta delay) {
   message_loop_proxy_->PostNonNestableDelayedTask(from_here, task, delay);
 }
 
 void MessageLoop::Run() {
+  DCHECK(!init_options_);
   RunLoop run_loop;
   run_loop.Run();
 }
 
 void MessageLoop::RunUntilIdle() {
+  DCHECK(!init_options_);
   RunLoop run_loop;
   run_loop.RunUntilIdle();
 }
 
 void MessageLoop::QuitWhenIdle() {
   DCHECK_EQ(this, current());
   if (run_loop_) {
     run_loop_->quit_when_idle_received_ = true;
   } else {
     NOTREACHED() << "Must be inside Run to call Quit";
@@ skipping 59 matching lines @@
 }
 
 bool MessageLoop::IsIdleForTesting() {
   // We only check the imcoming queue|, since we don't want to lock the work
   // queue.
   return incoming_task_queue_->IsIdleForTesting();
 }
 
 //------------------------------------------------------------------------------
 
-void MessageLoop::Init() {
-  DCHECK(!current()) << "should only have one message loop per thread";
-  lazy_tls_ptr.Pointer()->Set(this);
-
-  incoming_task_queue_ = new internal::IncomingTaskQueue(this);
-  message_loop_proxy_ =
-      new internal::MessageLoopProxyImpl(incoming_task_queue_);
-  thread_task_runner_handle_.reset(
-      new ThreadTaskRunnerHandle(message_loop_proxy_));
+void MessageLoop::ScheduleWork() {
+  pump_->ScheduleWork();
 }
 
 void MessageLoop::RunHandler() {
   DCHECK_EQ(this, current());
 
   StartHistogrammer();
 
 #if defined(OS_WIN)
   if (run_loop_->dispatcher_ && type() == TYPE_UI) {
     static_cast<MessagePumpForUI*>(pump_.get())->
@@ skipping 100 matching lines @@
   if (work_queue_.empty()) {
 #if defined(OS_WIN)
     pending_high_res_tasks_ +=
         incoming_task_queue_->ReloadWorkQueue(&work_queue_);
 #else
     incoming_task_queue_->ReloadWorkQueue(&work_queue_);
 #endif
   }
 }
 
-void MessageLoop::ScheduleWork() {
-  pump_->ScheduleWork();
-}
-
 //------------------------------------------------------------------------------
 // Method and data for histogramming events and actions taken by each instance
 // on each thread.
 
 void MessageLoop::StartHistogrammer() {
 #if !defined(OS_NACL)  // NaCl build has no metrics code.
   if (enable_histogrammer_ && !message_histogram_
       && StatisticsRecorder::IsActive()) {
     DCHECK(!thread_name_.empty());
     message_histogram_ = LinearHistogram::FactoryGetWithRangeDescription(
@@ skipping 182 matching lines @@
       persistent,
       mode,
       controller,
       delegate);
 }
 #endif
 
 #endif  // !defined(OS_NACL_SFI)
 
 }  // namespace base