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(MessageLoop::LazyInitOptions* options) {
+  if (options->message_pump_factory.is_null())
+    return options->message_loop_type;
+  return MessageLoop::TYPE_CUSTOM;
+}
+
 }  // namespace
 
 //------------------------------------------------------------------------------
 
+MessageLoop::LazyInitOptions::LazyInitOptions()
+    : message_loop_type(MessageLoop::TYPE_DEFAULT),
+      timer_slack(TIMER_SLACK_NONE) {
+}
+
+MessageLoop::LazyInitOptions::~LazyInitOptions() {
+}
+
+//------------------------------------------------------------------------------
+
 MessageLoop::TaskObserver::TaskObserver() {
 }
 
 MessageLoop::TaskObserver::~TaskObserver() {
 }
 
 MessageLoop::DestructionObserver::~DestructionObserver() {
 }
 
 //------------------------------------------------------------------------------
@@ skipping 26 matching lines @@
 #if defined(OS_WIN)
       os_modal_loop_(false),
 #endif  // OS_WIN
       message_histogram_(NULL),
       run_loop_(NULL) {
   DCHECK(pump_.get());
   Init();
 }
 
 MessageLoop::~MessageLoop() {
+  if (lazy_init_options_) {
+    // This message loop is destructed before we call LazyInit.
+    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 25 matching lines @@
   // Tell the incoming queue that we are dying.
   incoming_task_queue_->WillDestroyCurrentMessageLoop();
   incoming_task_queue_ = NULL;
   message_loop_proxy_ = NULL;
 
   // OK, now make it so that no one can find us.
   lazy_tls_ptr.Pointer()->Set(NULL);
 }
 
 // static
+MessageLoop* MessageLoop::CreateForLazyInit(
+    scoped_ptr<LazyInitOptions> options) {
+  return new MessageLoop(options.Pass());
+}
+
+// static
 MessageLoop* MessageLoop::current() {
   // TODO(darin): sadly, we cannot enable this yet since people call us even
   // when they have no intention of using us.
   // DCHECK(loop) << "Ouch, did you forget to initialize me?";
   return lazy_tls_ptr.Pointer()->Get();
 }
 
 // static
 void MessageLoop::EnableHistogrammer(bool enable) {
   enable_histogrammer_ = enable;
@@ skipping 45 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::LazyInit() {
+  DCHECK(lazy_init_options_)
+      << "should be called only when created for lazy init";
+  DCHECK(!current()) << "should only have one message loop per thread";
+  lazy_tls_ptr.Pointer()->Set(this);
+
+  if (!lazy_init_options_->message_pump_factory.is_null()) {
+    pump_ = lazy_init_options_->message_pump_factory.Run().Pass();
+  } else {
+    pump_ =
+        CreateMessagePumpForType(lazy_init_options_->message_loop_type).Pass();
+  }
+  SetTimerSlack(lazy_init_options_->timer_slack);
+  lazy_init_options_.reset();
+
+  incoming_task_queue_->DidInitializeMessageLoop();
+  message_loop_proxy_->LazyInit();
+  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 23 matching lines @@
 
 void MessageLoop::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
     const Closure& task,
     TimeDelta delay) {
   DCHECK(!task.is_null()) << from_here.ToString();
   incoming_task_queue_->AddToIncomingQueue(from_here, task, delay, false);
 }
 
 void MessageLoop::Run() {
+  DCHECK(!lazy_init_options_);
   RunLoop run_loop;
   run_loop.Run();
 }
 
 void MessageLoop::RunUntilIdle() {
+  DCHECK(!lazy_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();
 }
 
 //------------------------------------------------------------------------------
 
+MessageLoop::MessageLoop(scoped_ptr<LazyInitOptions> options)
+    : type_(GetMessageLoopType(options.get())),
+#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
+      lazy_init_options_(options.Pass()),
+      message_histogram_(NULL),
+      run_loop_(NULL) {
+  incoming_task_queue_ =
+      internal::IncomingTaskQueue::CreateForLazyInitMessageLoop(this);
+  message_loop_proxy_ =
+      internal::MessageLoopProxyImpl::CreateForLazyInit(incoming_task_queue_);
+}
+
 void MessageLoop::Init() {
+  DCHECK(!lazy_init_options_) << "should not be called when created for "
+                                 "lazy initialization";
   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_);
+      internal::MessageLoopProxyImpl::Create(incoming_task_queue_);
   thread_task_runner_handle_.reset(
       new ThreadTaskRunnerHandle(message_loop_proxy_));
 }
 
 void MessageLoop::RunHandler() {
   DCHECK_EQ(this, current());
 
   StartHistogrammer();
 
 #if defined(OS_WIN)
@@ skipping 308 matching lines @@
       persistent,
       mode,
       controller,
       delegate);
 }
 #endif
 
 #endif  // !defined(OS_NACL_SFI)
 
 }  // namespace base