Move message_pump to base/message_loop.

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/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop_proxy.h"
-#include "base/message_pump.h"
+#include "base/message_loop/message_pump.h"
 #include "base/observer_list.h"
 #include "base/pending_task.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "base/synchronization/lock.h"
 #include "base/tracking_info.h"
 #include "base/time.h"
 
 #if defined(OS_WIN)
 // We need this to declare base::MessagePumpWin::Dispatcher, which we should
 // really just eliminate.
-#include "base/message_pump_win.h"
+#include "base/message_loop/message_pump_win.h"
 #elif defined(OS_IOS)
-#include "base/message_pump_io_ios.h"
+#include "base/message_loop/message_pump_io_ios.h"
 #elif defined(OS_POSIX)
-#include "base/message_pump_libevent.h"
+#include "base/message_loop/message_pump_libevent.h"
 #if !defined(OS_MACOSX) && !defined(OS_ANDROID)
 
 #if defined(USE_AURA) && defined(USE_X11) && !defined(OS_NACL)
-#include "base/message_pump_aurax11.h"
+#include "base/message_loop/message_pump_aurax11.h"
 #elif defined(USE_OZONE) && !defined(OS_NACL)
-#include "base/message_pump_ozone.h"
+#include "base/message_loop/message_pump_ozone.h"
 #else
-#include "base/message_pump_gtk.h"
+#include "base/message_loop/message_pump_gtk.h"
 #endif
 
 #endif
 #endif
 
 namespace base {
+
 class HistogramBase;
 class MessageLoopLockTest;
 class RunLoop;
 class ThreadTaskRunnerHandle;
 #if defined(OS_ANDROID)
 class MessagePumpForUI;
 #endif
 
 // A MessageLoop is used to process events for a particular thread.  There is
 // at most one MessageLoop instance per thread.
@@ skipping 19 matching lines @@
 //   HRESULT hr;
 //   {
 //     MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
 //     hr = DoDragDrop(...); // Implicitly runs a modal message loop.
 //   }
 //   // Process |hr| (the result returned by DoDragDrop()).
 //
 // Please be SURE your task is reentrant (nestable) and all global variables
 // are stable and accessible before calling SetNestableTasksAllowed(true).
 //
-class BASE_EXPORT MessageLoop : public base::MessagePump::Delegate {
+class BASE_EXPORT MessageLoop : public MessagePump::Delegate {
  public:
 
 #if !defined(OS_MACOSX) && !defined(OS_ANDROID)
-  typedef base::MessagePumpDispatcher Dispatcher;
-  typedef base::MessagePumpObserver Observer;
+  typedef MessagePumpDispatcher Dispatcher;
+  typedef MessagePumpObserver Observer;
 #endif
 
   // A MessageLoop has a particular type, which indicates the set of
   // asynchronous events it may process in addition to tasks and timers.
   //
   // TYPE_DEFAULT
   //   This type of ML only supports tasks and timers.
   //
   // TYPE_UI
   //   This type of ML also supports native UI events (e.g., Windows messages).
@@ skipping 12 matching lines @@
   // 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);
   virtual ~MessageLoop();
 
   // Returns the MessageLoop object for the current thread, or null if none.
   static MessageLoop* current();
 
   static void EnableHistogrammer(bool enable_histogrammer);
 
-  typedef base::MessagePump* (MessagePumpFactory)();
+  typedef 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);
 
   // A DestructionObserver is notified when the current MessageLoop is being
   // destroyed.  These observers are notified prior to MessageLoop::current()
   // being changed to return NULL.  This gives interested parties the chance to
   // do final cleanup that depends on the MessageLoop.
   //
@@ skipping 32 matching lines @@
   //
   // PostTask(from_here, task) is equivalent to
   // PostDelayedTask(from_here, task, 0).
   //
   // The TryPostTask is meant for the cases where the calling thread cannot
   // block. If posting the task will block, the call returns false, the task
   // is not posted but the task is consumed anyways.
   //
   // NOTE: These methods may be called on any thread.  The Task will be invoked
   // on the thread that executes MessageLoop::Run().
-  void PostTask(
-      const tracked_objects::Location& from_here,
-      const base::Closure& task);
+  void PostTask(const tracked_objects::Location& from_here,
+                const Closure& task);
 
-  bool TryPostTask(
-      const tracked_objects::Location& from_here,
-      const base::Closure& task);
+  bool TryPostTask(const tracked_objects::Location& from_here,
+                   const Closure& task);
 
-  void PostDelayedTask(
-      const tracked_objects::Location& from_here,
-      const base::Closure& task,
-      base::TimeDelta delay);
+  void PostDelayedTask(const tracked_objects::Location& from_here,
+                       const Closure& task,
+                       TimeDelta delay);
 
-  void PostNonNestableTask(
-      const tracked_objects::Location& from_here,
-      const base::Closure& task);
+  void PostNonNestableTask(const tracked_objects::Location& from_here,
+                           const Closure& task);
 
-  void PostNonNestableDelayedTask(
-      const tracked_objects::Location& from_here,
-      const base::Closure& task,
-      base::TimeDelta delay);
+  void PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
+                                  const Closure& task,
+                                  TimeDelta delay);
 
   // A variant on PostTask that deletes the given object.  This is useful
   // if the object needs to live until the next run of the MessageLoop (for
   // example, deleting a RenderProcessHost from within an IPC callback is not
   // good).
   //
   // NOTE: This method may be called on any thread.  The object will be deleted
   // on the thread that executes MessageLoop::Run().  If this is not the same
   // as the thread that calls PostDelayedTask(FROM_HERE, ), then T MUST inherit
   // from RefCountedThreadSafe<T>!
@@ skipping 49 matching lines @@
   // which nested run loop you are quitting, so be careful!
   void QuitWhenIdle();
 
   // Deprecated: use RunLoop instead.
   //
   // This method is a variant of Quit, that does not wait for pending messages
   // to be processed before returning from Run.
   void QuitNow();
 
   // TODO(jbates) remove this. crbug.com/131220. See QuitWhenIdleClosure().
-  static base::Closure QuitClosure() { return QuitWhenIdleClosure(); }
+  static Closure QuitClosure() { return QuitWhenIdleClosure(); }
 
   // Deprecated: use RunLoop instead.
   // Construct a Closure that will call QuitWhenIdle(). Useful to schedule an
   // arbitrary MessageLoop to QuitWhenIdle.
-  static base::Closure QuitWhenIdleClosure();
+  static Closure QuitWhenIdleClosure();
 
   // Returns true if this loop is |type|. This allows subclasses (especially
   // those in tests) to specialize how they are identified.
   virtual bool IsType(Type type) const;
 
   // Returns the type passed to the constructor.
   Type type() const { return type_; }
 
   // Optional call to connect the thread name with this loop.
   void set_thread_name(const std::string& thread_name) {
     DCHECK(thread_name_.empty()) << "Should not rename this thread!";
     thread_name_ = thread_name;
   }
   const std::string& thread_name() const { return thread_name_; }
 
   // Gets the message loop proxy associated with this message loop.
-  scoped_refptr<base::MessageLoopProxy> message_loop_proxy() {
+  scoped_refptr<MessageLoopProxy> message_loop_proxy() {
     return message_loop_proxy_.get();
   }
 
   // Enables or disables the recursive task processing. This happens in the case
   // of recursive message loops. Some unwanted message loop may occurs when
   // using common controls or printer functions. By default, recursive task
   // processing is disabled.
   //
   // Please utilize |ScopedNestableTaskAllower| instead of calling these methods
   // directly.  In general nestable message loops are to be avoided.  They are
@@ skipping 42 matching lines @@
 
   // A TaskObserver is an object that receives task notifications from the
   // MessageLoop.
   //
   // NOTE: A TaskObserver implementation should be extremely fast!
   class BASE_EXPORT TaskObserver {
    public:
     TaskObserver();
 
     // This method is called before processing a task.
-    virtual void WillProcessTask(const base::PendingTask& pending_task) = 0;
+    virtual void WillProcessTask(const PendingTask& pending_task) = 0;
 
     // This method is called after processing a task.
-    virtual void DidProcessTask(const base::PendingTask& pending_task) = 0;
+    virtual void DidProcessTask(const PendingTask& pending_task) = 0;
 
    protected:
     virtual ~TaskObserver();
   };
 
   // These functions can only be called on the same thread that |this| is
   // running on.
   void AddTaskObserver(TaskObserver* task_observer);
   void RemoveTaskObserver(TaskObserver* task_observer);
 
@@ skipping 24 matching lines @@
   }
 #endif  // OS_WIN
 
   // Can only be called from the thread that owns the MessageLoop.
   bool is_running() const;
 
   //----------------------------------------------------------------------------
  protected:
 
 #if defined(OS_WIN)
-  base::MessagePumpWin* pump_win() {
-    return static_cast<base::MessagePumpWin*>(pump_.get());
+  MessagePumpWin* pump_win() {
+    return static_cast<MessagePumpWin*>(pump_.get());
   }
 #elif defined(OS_POSIX) && !defined(OS_IOS)
-  base::MessagePumpLibevent* pump_libevent() {
-    return static_cast<base::MessagePumpLibevent*>(pump_.get());
+  MessagePumpLibevent* pump_libevent() {
+    return static_cast<MessagePumpLibevent*>(pump_.get());
   }
 #endif
 
-  scoped_refptr<base::MessagePump> pump_;
+  scoped_refptr<MessagePump> pump_;
 
  private:
-  friend class base::RunLoop;
-  friend class base::MessageLoopLockTest;
+  friend class RunLoop;
+  friend class MessageLoopLockTest;
 
   // A function to encapsulate all the exception handling capability in the
   // stacks around the running of a main message loop.  It will run the message
   // loop in a SEH try block or not depending on the set_SEH_restoration()
   // flag invoking respectively RunInternalInSEHFrame() or RunInternal().
   void RunHandler();
 
 #if defined(OS_WIN)
   __declspec(noinline) void RunInternalInSEHFrame();
 #endif
 
   // A surrounding stack frame around the running of the message loop that
   // supports all saving and restoring of state, as is needed for any/all (ugly)
   // recursive calls.
   void RunInternal();
 
   // Called to process any delayed non-nestable tasks.
   bool ProcessNextDelayedNonNestableTask();
 
   // Runs the specified PendingTask.
-  void RunTask(const base::PendingTask& pending_task);
+  void RunTask(const PendingTask& pending_task);
 
   // 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.
-  bool DeferOrRunPendingTask(const base::PendingTask& pending_task);
+  bool DeferOrRunPendingTask(const PendingTask& pending_task);
 
   // Adds the pending task to delayed_work_queue_.
-  void AddToDelayedWorkQueue(const base::PendingTask& pending_task);
+  void AddToDelayedWorkQueue(const PendingTask& pending_task);
 
   // This function attempts to add pending task to our incoming_queue_.
   // The append can only possibly fail when |use_try_lock| is true.
   //
   // When |use_try_lock| is true, then this call will avoid blocking if
   // the related lock is already held, and will in that case (when the
   // lock is contended) fail to perform the append, and will return false.
   //
   // If the call succeeds to append to the queue, then this call
   // will return true.
   //
   // In all cases, the caller retains ownership of |pending_task|, but this
   // function will reset the value of pending_task->task.  This is needed to
   // ensure that the posting call stack does not retain pending_task->task
   // beyond this function call.
-  bool AddToIncomingQueue(base::PendingTask* pending_task, bool use_try_lock);
+  bool AddToIncomingQueue(PendingTask* pending_task, bool use_try_lock);
 
   // Load tasks from the incoming_queue_ into work_queue_ if the latter is
   // empty.  The former requires a lock to access, while the latter is directly
   // accessible on this thread.
   void ReloadWorkQueue();
 
   // Delete tasks that haven't run yet without running them.  Used in the
   // destructor to make sure all the task's destructors get called.  Returns
   // true if some work was done.
   bool DeletePendingTasks();
 
   // Calculates the time at which a PendingTask should run.
-  base::TimeTicks CalculateDelayedRuntime(base::TimeDelta delay);
+  TimeTicks CalculateDelayedRuntime(TimeDelta delay);
 
   // Start recording histogram info about events and action IF it was enabled
   // and IF the statistics recorder can accept a registration of our histogram.
   void StartHistogrammer();
 
   // Add occurrence of event to our histogram, so that we can see what is being
   // done in a specific MessageLoop instance (i.e., specific thread).
   // If message_histogram_ is NULL, this is a no-op.
   void HistogramEvent(int event);
 
-  // base::MessagePump::Delegate methods:
+  // MessagePump::Delegate methods:
   virtual bool DoWork() OVERRIDE;
-  virtual bool DoDelayedWork(base::TimeTicks* next_delayed_work_time) OVERRIDE;
+  virtual bool DoDelayedWork(TimeTicks* next_delayed_work_time) OVERRIDE;
   virtual bool DoIdleWork() OVERRIDE;
 
   Type type_;
 
   // A list of tasks that need to be processed by this instance.  Note that
   // this queue is only accessed (push/pop) by our current thread.
-  base::TaskQueue work_queue_;
+  TaskQueue work_queue_;
 
   // Contains delayed tasks, sorted by their 'delayed_run_time' property.
-  base::DelayedTaskQueue delayed_work_queue_;
+  DelayedTaskQueue delayed_work_queue_;
 
   // A recent snapshot of Time::Now(), used to check delayed_work_queue_.
-  base::TimeTicks recent_time_;
+  TimeTicks recent_time_;
 
   // A queue of non-nestable tasks that we had to defer because when it came
   // time to execute them we were in a nested message loop.  They will execute
   // once we're out of nested message loops.
-  base::TaskQueue deferred_non_nestable_work_queue_;
+  TaskQueue deferred_non_nestable_work_queue_;
 
   ObserverList<DestructionObserver> destruction_observers_;
 
   // A recursion block that prevents accidentally running additional tasks when
   // insider a (accidentally induced?) nested message pump.
   bool nestable_tasks_allowed_;
 
   bool exception_restoration_;
 
   std::string thread_name_;
   // A profiling histogram showing the counts of various messages and events.
-  base::HistogramBase* message_histogram_;
+  HistogramBase* message_histogram_;
 
   // An incoming queue of tasks that are acquired under a mutex for processing
   // on this instance's thread. These tasks have not yet been sorted out into
   // items for our work_queue_ vs delayed_work_queue_.
-  base::TaskQueue incoming_queue_;
+  TaskQueue incoming_queue_;
   // Protect access to incoming_queue_.
-  mutable base::Lock incoming_queue_lock_;
+  mutable Lock incoming_queue_lock_;
 
-  base::RunLoop* run_loop_;
+  RunLoop* run_loop_;
 
 #if defined(OS_WIN)
-  base::TimeTicks high_resolution_timer_expiration_;
+  TimeTicks high_resolution_timer_expiration_;
   // Should be set to true before calling Windows APIs like TrackPopupMenu, etc
   // which enter a modal message loop.
   bool os_modal_loop_;
 #endif
 
   // The next sequence number to use for delayed tasks. Updating this counter is
   // protected by incoming_queue_lock_.
   int next_sequence_num_;
 
   ObserverList<TaskObserver> task_observers_;
 
   // The message loop proxy associated with this message loop, if one exists.
-  scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
-  scoped_ptr<base::ThreadTaskRunnerHandle> thread_task_runner_handle_;
+  scoped_refptr<MessageLoopProxy> 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,
                           void(*deleter)(const void*),
                           const void* object);
   void ReleaseSoonInternal(const tracked_objects::Location& from_here,
                            void(*releaser)(const void*),
                            const void* object);
 
   DISALLOW_COPY_AND_ASSIGN(MessageLoop);
 };
 
 //-----------------------------------------------------------------------------
 // MessageLoopForUI extends MessageLoop with methods that are particular to a
 // MessageLoop instantiated with TYPE_UI.
 //
 // This class is typically used like so:
 //   MessageLoopForUI::current()->...call some method...
 //
 class BASE_EXPORT MessageLoopForUI : public MessageLoop {
  public:
 #if defined(OS_WIN)
-  typedef base::MessagePumpForUI::MessageFilter MessageFilter;
+  typedef MessagePumpForUI::MessageFilter MessageFilter;
 #endif
 
   MessageLoopForUI() : MessageLoop(TYPE_UI) {
   }
 
   // Returns the MessageLoopForUI of the current thread.
   static MessageLoopForUI* current() {
     MessageLoop* loop = MessageLoop::current();
     DCHECK(loop);
     DCHECK_EQ(MessageLoop::TYPE_UI, loop->type());
@@ skipping 25 matching lines @@
 
 #if defined(OS_WIN)
   // Plese see MessagePumpForUI for definitions of this method.
   void SetMessageFilter(scoped_ptr<MessageFilter> message_filter) {
     pump_ui()->SetMessageFilter(message_filter.Pass());
   }
 #endif
 
  protected:
 #if defined(USE_AURA) && defined(USE_X11) && !defined(OS_NACL)
-  friend class base::MessagePumpAuraX11;
+  friend class MessagePumpAuraX11;
 #endif
 #if defined(USE_OZONE) && !defined(OS_NACL)
-  friend class base::MessagePumpOzone;
+  friend class MessagePumpOzone;
 #endif
 
   // TODO(rvargas): Make this platform independent.
-  base::MessagePumpForUI* pump_ui() {
-    return static_cast<base::MessagePumpForUI*>(pump_.get());
+  MessagePumpForUI* pump_ui() {
+    return static_cast<MessagePumpForUI*>(pump_.get());
   }
 #endif  // !defined(OS_MACOSX)
 };
 
 // Do not add any member variables to MessageLoopForUI!  This is important b/c
 // MessageLoopForUI is often allocated via MessageLoop(TYPE_UI).  Any extra
 // data that you need should be stored on the MessageLoop's pump_ instance.
 COMPILE_ASSERT(sizeof(MessageLoop) == sizeof(MessageLoopForUI),
                MessageLoopForUI_should_not_have_extra_member_variables);
 
 //-----------------------------------------------------------------------------
 // MessageLoopForIO extends MessageLoop with methods that are particular to a
 // MessageLoop instantiated with TYPE_IO.
 //
 // This class is typically used like so:
 //   MessageLoopForIO::current()->...call some method...
 //
 class BASE_EXPORT MessageLoopForIO : public MessageLoop {
  public:
 #if defined(OS_WIN)
-  typedef base::MessagePumpForIO::IOHandler IOHandler;
-  typedef base::MessagePumpForIO::IOContext IOContext;
-  typedef base::MessagePumpForIO::IOObserver IOObserver;
+  typedef MessagePumpForIO::IOHandler IOHandler;
+  typedef MessagePumpForIO::IOContext IOContext;
+  typedef MessagePumpForIO::IOObserver IOObserver;
 #elif defined(OS_IOS)
-  typedef base::MessagePumpIOSForIO::Watcher Watcher;
-  typedef base::MessagePumpIOSForIO::FileDescriptorWatcher
+  typedef MessagePumpIOSForIO::Watcher Watcher;
+  typedef MessagePumpIOSForIO::FileDescriptorWatcher
       FileDescriptorWatcher;
-  typedef base::MessagePumpIOSForIO::IOObserver IOObserver;
+  typedef MessagePumpIOSForIO::IOObserver IOObserver;
 
   enum Mode {
-    WATCH_READ = base::MessagePumpIOSForIO::WATCH_READ,
-    WATCH_WRITE = base::MessagePumpIOSForIO::WATCH_WRITE,
-    WATCH_READ_WRITE = base::MessagePumpIOSForIO::WATCH_READ_WRITE
+    WATCH_READ = MessagePumpIOSForIO::WATCH_READ,
+    WATCH_WRITE = MessagePumpIOSForIO::WATCH_WRITE,
+    WATCH_READ_WRITE = MessagePumpIOSForIO::WATCH_READ_WRITE
   };
 #elif defined(OS_POSIX)
-  typedef base::MessagePumpLibevent::Watcher Watcher;
-  typedef base::MessagePumpLibevent::FileDescriptorWatcher
+  typedef MessagePumpLibevent::Watcher Watcher;
+  typedef MessagePumpLibevent::FileDescriptorWatcher
       FileDescriptorWatcher;
-  typedef base::MessagePumpLibevent::IOObserver IOObserver;
+  typedef MessagePumpLibevent::IOObserver IOObserver;
 
   enum Mode {
-    WATCH_READ = base::MessagePumpLibevent::WATCH_READ,
-    WATCH_WRITE = base::MessagePumpLibevent::WATCH_WRITE,
-    WATCH_READ_WRITE = base::MessagePumpLibevent::WATCH_READ_WRITE
+    WATCH_READ = MessagePumpLibevent::WATCH_READ,
+    WATCH_WRITE = MessagePumpLibevent::WATCH_WRITE,
+    WATCH_READ_WRITE = MessagePumpLibevent::WATCH_READ_WRITE
   };
 
 #endif
 
   MessageLoopForIO() : MessageLoop(TYPE_IO) {
   }
 
   // Returns the MessageLoopForIO of the current thread.
   static MessageLoopForIO* current() {
     MessageLoop* loop = MessageLoop::current();
@@ skipping 10 matching lines @@
   }
 
 #if defined(OS_WIN)
   // Please see MessagePumpWin for definitions of these methods.
   void RegisterIOHandler(HANDLE file, IOHandler* handler);
   bool RegisterJobObject(HANDLE job, IOHandler* handler);
   bool WaitForIOCompletion(DWORD timeout, IOHandler* filter);
 
  protected:
   // TODO(rvargas): Make this platform independent.
-  base::MessagePumpForIO* pump_io() {
-    return static_cast<base::MessagePumpForIO*>(pump_.get());
+  MessagePumpForIO* pump_io() {
+    return static_cast<MessagePumpForIO*>(pump_.get());
   }
 
 #elif defined(OS_IOS)
   // Please see MessagePumpIOSForIO for definition.
   bool WatchFileDescriptor(int fd,
                            bool persistent,
                            Mode mode,
                            FileDescriptorWatcher *controller,
                            Watcher *delegate);
 
  private:
-  base::MessagePumpIOSForIO* pump_io() {
-    return static_cast<base::MessagePumpIOSForIO*>(pump_.get());
+  MessagePumpIOSForIO* pump_io() {
+    return static_cast<MessagePumpIOSForIO*>(pump_.get());
   }
 
 #elif defined(OS_POSIX)
   // Please see MessagePumpLibevent for definition.
   bool WatchFileDescriptor(int fd,
                            bool persistent,
                            Mode mode,
                            FileDescriptorWatcher* controller,
                            Watcher* delegate);
 
  private:
-  base::MessagePumpLibevent* pump_io() {
-    return static_cast<base::MessagePumpLibevent*>(pump_.get());
+  MessagePumpLibevent* pump_io() {
+    return static_cast<MessagePumpLibevent*>(pump_.get());
   }
 #endif  // defined(OS_POSIX)
 };
 
 // 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_