Remove calls to MessageLoop::current() in base.

base/threading/thread.h

 // Copyright (c) 2012 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_THREADING_THREAD_H_
 #define BASE_THREADING_THREAD_H_
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 
 #include "base/base_export.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/timer_slack.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 
 namespace base {
 
 class MessagePump;
+class RunLoop;
 
 // A simple thread abstraction that establishes a MessageLoop on a new thread.
 // The consumer uses the MessageLoop of the thread to cause code to execute on
 // the thread.  When this object is destroyed the thread is terminated.  All
 // pending tasks queued on the thread's message loop will run to completion
 // before the thread is terminated.
 //
 // WARNING! SUBCLASSES MUST CALL Stop() IN THEIR DESTRUCTORS!  See ~Thread().
 //
 // After the thread is stopped, the destruction sequence is:
@@ skipping 146 matching lines @@
   //
   PlatformThreadId GetThreadId() const;
 
   // Returns true if the thread has been started, and not yet stopped.
   bool IsRunning() const;
 
  protected:
   // Called just prior to starting the message loop
   virtual void Init() {}
 
-  // Called to start the message loop
-  virtual void Run(MessageLoop* message_loop);
+  // Called to start the run loop
+  virtual void Run(RunLoop* run_loop);
 
   // Called just after the message loop ends
   virtual void CleanUp() {}
 
   static void SetThreadWasQuitProperly(bool flag);
   static bool GetThreadWasQuitProperly();
 
   void set_message_loop(MessageLoop* message_loop) {
     message_loop_ = message_loop;
   }
 
  private:
 #if defined(OS_WIN)
   enum ComStatus {
     NONE,
     STA,
     MTA,
   };
 #endif
 
   // PlatformThread::Delegate methods:
   void ThreadMain() override;
 
+  void ThreadQuitHelper();
+
 #if defined(OS_WIN)
   // Whether this thread needs to initialize COM, and if so, in what mode.
   ComStatus com_status_;
 #endif
 
   // If true, we're in the middle of stopping, and shouldn't access
   // |message_loop_|. It may non-nullptr and invalid.
   // Should be written on the thread that created this thread. Also read data
   // could be wrong on other threads.
   bool stopping_;
 
   // True while inside of Run().
   bool running_;
   mutable base::Lock running_lock_;  // Protects |running_|.
 
   // The thread's handle.
   PlatformThreadHandle thread_;
   mutable base::Lock thread_lock_;  // Protects |thread_|.
 
   // The thread's id once it has started.
   PlatformThreadId id_;
   mutable WaitableEvent id_event_;  // Protects |id_|.
 
-  // The thread's message loop.  Valid only while the thread is alive.  Set
-  // by the created thread.
+  // The thread's MessageLoop and RunLoop. Valid only while the thread is alive.
+  // Set by the created thread.
   MessageLoop* message_loop_;
+  RunLoop* run_loop_;

[gab, 2016/07/21 19:10:51]

Note: this turns out to not be relevant in this specific case but this variable
isn't initialized in constructor, fixed in
https://codereview.chromium.org/2145463002 :-)

 
   // Stores Options::timer_slack_ until the message loop has been bound to
   // a thread.
   TimerSlack message_loop_timer_slack_;
 
   // The name of the thread.  Used for debugging purposes.
   std::string name_;
 
   // Signaled when the created thread gets ready to use the message loop.
   mutable WaitableEvent start_event_;
 
-  friend void ThreadQuitHelper();
-
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_THREAD_H_