Lazily initialize MessageLoop for faster thread startup

base/message_loop/message_loop.h

 // 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.
 
 #ifndef BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_
 #define BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_
 
 #include <queue>
 #include <string>
 
@@ skipping 91 matching lines @@
   enum Type {
     TYPE_DEFAULT,
     TYPE_UI,
     TYPE_CUSTOM,
     TYPE_IO,
 #if defined(OS_ANDROID)
     TYPE_JAVA,
 #endif  // defined(OS_ANDROID)
   };
 
+  // Init options for CreateForLazyInit().
+  struct BASE_EXPORT LazyInitOptions {
+    using MessagePumpFactory = Callback<scoped_ptr<MessagePump>()>;
+    LazyInitOptions();
+    ~LazyInitOptions();
+
+    // Specify the type of message loop that will be initialized in LazyInit.
+    // This is ignored if message_pump_factory.is_null() is false.
+    MessageLoop::Type message_loop_type;
+
+    // Specify timer slack for the message loop.
+    TimerSlack timer_slack;
+
+    // Used to create the MessagePump for the MessageLoop in LazyInit.
+    // If message_pump_factory.is_null() is true, then a MessagePump appropriate
+    // for |message_loop_type| is created. Setting this forces the
+    // MessageLoop::Type to TYPE_CUSTOM.
+    MessagePumpFactory message_pump_factory;
+  };
+
   // Normally, it is not necessary to instantiate a MessageLoop.  Instead, it
   // is typical to make use of the current thread's MessageLoop instance.
   explicit MessageLoop(Type type = TYPE_DEFAULT);
   // Creates a TYPE_CUSTOM MessageLoop with the supplied MessagePump, which must
   // be non-NULL.
-  explicit MessageLoop(scoped_ptr<base::MessagePump> pump);
+  explicit MessageLoop(scoped_ptr<MessagePump> pump);
   ~MessageLoop() override;
 
+  // Creates a MessageLoop for lazy initialization. This can be called on a
+  // different thread from the final 'current' thread of this message loop
+  // to pre-construct a message loop that accepts incoming tasks before
+  // the thread becomes ready to run. The caller must call LazyInit method
+  // on the final 'current' thread before calling Run to start running
+  // tasks.
+  //
+  // Note that until LazyInit() is called on the final 'current' thread
+  // only "PostTask" family methods can be called to 'queue' a task.
+  // Usually this should not be a problem in production code, because
+  // almost all other methods (except for ScheduleWork) are allowed to be
+  // called only on the final 'current' thread where the message loop's Run
+  // method runs, and no tasks can run there until the message loop actually
+  // spins up and calls Run, which must happen after LazyInit.
+  //
+  // Typical usage of CreateForLazyInit should look like following:
+  //
+  //   // On the calling thread:
+  //   {
+  //     scoped_ptr<MessageLoop::LazyInitOptions> options(new
+  //        MessageLoop::LazyInitOptions);
+  //     options->message_loop_type = YOUR_MESSAGE_LOOP_TYPE;
+  //     options->timer_slack = YOUR_TIMER_SLACK;
+  //     ...
+  //
+  //     message_loop_ = MessageLoop::CreateForLazyInit(options.Pass());
+  //     // Right after here the caller can start posting tasks to this
+  //     // message loop, though it won't run until LazyInit and Run is
+  //     // called on the target thread.
+  //
+  //     PlatformThread::Create(...);
+  //   }
+  //
+  //   // On the target thread where the message loop actually runs:
+  //   void ThreadMain() {
+  //     // Do the remaining initialization. This also sets up current().
+  //     message_loop_->LazyInit();
+  //
+  //     // Start running the loop.
+  //     message_loop_->Run();
+  //   }
+  //
+  static MessageLoop* CreateForLazyInit(scoped_ptr<LazyInitOptions> options);

[rvargas (doing something else), 2015/03/26 02:19:27]

should return a scoped_ptr

[rvargas (doing something else), 2015/03/26 02:19:27]

nit: Do we really need the "ForLazyInit" part?. This should be the default way
to create MessageLoops (except for tests or the main thread) and the name sort
of implies that this is a special case.

[kinuko, 2015/04/13 02:02:59]

Done.

+
   // Returns the MessageLoop object for the current thread, or null if none.
   static MessageLoop* current();
 
   static void EnableHistogrammer(bool enable_histogrammer);
 
   typedef scoped_ptr<MessagePump> (MessagePumpFactory)();
   // Uses the given base::MessagePumpForUIFactory to override the default
   // MessagePump implementation for 'TYPE_UI'. Returns true if the factory
   // was successfully registered.
   static bool InitMessagePumpForUIFactory(MessagePumpFactory* factory);
@@ skipping 10 matching lines @@
   // not be run.  Instead, they will be deleted.
   //
   class BASE_EXPORT DestructionObserver {
    public:
     virtual void WillDestroyCurrentMessageLoop() = 0;
 
    protected:
     virtual ~DestructionObserver();
   };
 
+  // Configure various members and bind this message loop to the current thread.
+  // This must be called on the final 'current' thread of this message loop.
+  // It is not valid to call this unless this message loop is constructed by
+  // CreateForLazyInit.
+  // (See the comment at CreateForLazyInit for more details)
+  void LazyInit();
+
   // Add a DestructionObserver, which will start receiving notifications
   // immediately.
   void AddDestructionObserver(DestructionObserver* destruction_observer);
 
   // Remove a DestructionObserver.  It is safe to call this method while a
   // DestructionObserver is receiving a notification callback.
   void RemoveDestructionObserver(DestructionObserver* destruction_observer);
 
   // NOTE: Deprecated; prefer task_runner() and the TaskRunner interfaces.
   // TODO(skyostil): Remove these functions (crbug.com/465354).
@@ skipping 245 matching lines @@
   // Runs the specified PendingTask.
   void RunTask(const PendingTask& pending_task);
 
   //----------------------------------------------------------------------------
  protected:
   scoped_ptr<MessagePump> pump_;
 
  private:
   friend class RunLoop;
 
-  // Configures various members for the two constructors.
+  // Private constructor for CreateForLazyInit().
+  explicit MessageLoop(scoped_ptr<LazyInitOptions> options);
+
+  // Configures various members for the two public constructors.
   void Init();
 
   // Invokes the actual run loop using the message pump.
   void RunHandler();
 
   // Called to process any delayed non-nestable tasks.
   bool ProcessNextDelayedNonNestableTask();
 
   // Calls RunTask or queues the pending_task on the deferred task list if it
   // cannot be run right now.  Returns true if the task was run.
@@ skipping 57 matching lines @@
   // A recursion block that prevents accidentally running additional tasks when
   // insider a (accidentally induced?) nested message pump.
   bool nestable_tasks_allowed_;
 
 #if defined(OS_WIN)
   // Should be set to true before calling Windows APIs like TrackPopupMenu, etc
   // which enter a modal message loop.
   bool os_modal_loop_;
 #endif
 
+  // Non-null only when this message loop is constructed by CreateForLazyInit.
+  scoped_ptr<LazyInitOptions> lazy_init_options_;
+
   std::string thread_name_;
   // A profiling histogram showing the counts of various messages and events.
   HistogramBase* message_histogram_;
 
   RunLoop* run_loop_;
 
   ObserverList<TaskObserver> task_observers_;
 
   debug::TaskAnnotator task_annotator_;
 
@@ skipping 151 matching lines @@
 
 // Do not add any member variables to MessageLoopForIO!  This is important b/c
 // MessageLoopForIO is often allocated via MessageLoop(TYPE_IO).  Any extra
 // data that you need should be stored on the MessageLoop's pump_ instance.
 COMPILE_ASSERT(sizeof(MessageLoop) == sizeof(MessageLoopForIO),
                MessageLoopForIO_should_not_have_extra_member_variables);
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_