[Approach 3] Pre-allocate IncomigTaskQueue before 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>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
-#include "base/debug/task_annotator.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/incoming_task_queue.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/message_loop/message_loop_proxy_impl.h"
 #include "base/message_loop/message_pump.h"
 #include "base/message_loop/timer_slack.h"
 #include "base/observer_list.h"
 #include "base/pending_task.h"
@@ skipping 77 matching lines @@
   enum Type {
     TYPE_DEFAULT,
     TYPE_UI,
     TYPE_CUSTOM,
     TYPE_IO,
 #if defined(OS_ANDROID)
     TYPE_JAVA,
 #endif  // defined(OS_ANDROID)
   };
 
+  struct BASE_EXPORT Options {
+    using MessagePumpFactory = Callback<scoped_ptr<MessagePump>()>;
+    Options();
+    ~Options();
+
+    // Specify the type of message loop.
+    // This is ignored if message_pump_factory.is_null() is false.
+    MessageLoop::Type message_loop_type;
+
+    // Used to create the MessagePump for the MessageLoop.
+    // 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;
+
+    // If non-null incoming_task_queue is specified this message loop will
+    // use it as its incoming task queue.
+    scoped_refptr<internal::IncomingTaskQueue> incoming_task_queue;
+  };
+
   // 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(const Options& options);
+
+  // Creates a MessageLoop for the supplied type. This constructor is used
+  // only for testing.
   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);
+  // be non-NULL. This constructor is used only for testing.
+  explicit MessageLoop(scoped_ptr<MessagePump> pump);
   ~MessageLoop() override;
 
   // 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
@@ skipping 265 matching lines @@
 
   // Returns true if the message loop is "idle". Provided for testing.
   bool IsIdleForTesting();
 
   // Wakes up the message pump. Can be called on any thread. The caller is
   // responsible for synchronizing ScheduleWork() calls.
   void ScheduleWork();
 
   // Returns the TaskAnnotator which is used to add debug information to posted
   // tasks.
-  debug::TaskAnnotator* task_annotator() { return &task_annotator_; }
+  debug::TaskAnnotator* task_annotator() {
+    return incoming_task_queue_->task_annotator();
+  }
 
   // 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.
+  // Configures various members for the 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 65 matching lines @@
 #endif
 
   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_;
-
   scoped_refptr<internal::IncomingTaskQueue> incoming_task_queue_;
 
   // The message loop proxy associated with this message loop.
   scoped_refptr<internal::MessageLoopProxyImpl> message_loop_proxy_;
   scoped_ptr<ThreadTaskRunnerHandle> thread_task_runner_handle_;
 
   template <class T, class R> friend class base::subtle::DeleteHelperInternal;
   template <class T, class R> friend class base::subtle::ReleaseHelperInternal;
 
   void DeleteSoonInternal(const tracked_objects::Location& from_here,
@@ skipping 141 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_