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 until
+  // LazyInit() is called.
+  // Note that only "PostTask" family methods can be called and posted tasks

[DaleCurtis, 2015/03/18 22:04:28]

Seems error prone; what methods exactly shouldn't be called? We'll get flaky
failures if someone accidentally calls something else, no?

[kinuko, 2015/03/19 03:08:16]

To be sure, almost all other methods (except for ScheduleWork()) are not
expected to be called on a different thread from the 'current' one, and until
this is called no task can run on the 'current' thread, so this shouldn't be
usually a problem (I think).

I elaborated the comment a little more.

+  // won't run before LazyInit() is called.
+  static MessageLoop* CreateForLazyInit(scoped_ptr<LazyInitOptions> options);
+
   // 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 for the private constructor for
+  // CreateForLazyInit().
+  // 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().
+  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);
 
   // The "PostTask" family of methods call the task's Run method asynchronously
   // from within a message loop at some point in the future.
@@ skipping 240 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_