Make RunLoop::Quit() thread-safe.

base/run_loop.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_RUN_LOOP_H_
 #define BASE_RUN_LOOP_H_
 
 #include <stack>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/callback.h"
 #include "base/macros.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/sequence_checker.h"
 #include "base/threading/thread_checker.h"
 #include "build/build_config.h"
 
 namespace base {
 #if defined(OS_ANDROID)
 class MessagePumpForUI;
 #endif
 
 #if defined(OS_IOS)
 class MessagePumpUIApplication;
 #endif
 
+class SingleThreadTaskRunner;
+
 // Helper class to run the RunLoop::Delegate associated with the current thread.
 // A RunLoop::Delegate must have been bound to this thread (ref.
 // RunLoop::RegisterDelegateForCurrentThread()) prior to using any of RunLoop's
 // member and static methods unless explicitly indicated otherwise (e.g.
 // IsRunning/IsNestedOnCurrentThread()). RunLoop::Run can only be called once
 // per RunLoop lifetime. Create a RunLoop on the stack and call Run/Quit to run
 // a nested RunLoop but please do not use nested loops in production code!
 class BASE_EXPORT RunLoop {
  public:
   RunLoop();
@@ skipping 13 matching lines @@
   void RunUntilIdle();
 
   bool running() const {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     return running_;
   }
 
   // Quit() quits an earlier call to Run() immediately. QuitWhenIdle() quits an
   // earlier call to Run() when there aren't any tasks or messages in the queue.
   //
+  // These methods are thread-safe but note that Quit() is best-effort when
+  // called from another thread (will quit soon but tasks that were already
+  // queued on this RunLoop will get to run first).
+  //
   // There can be other nested RunLoops servicing the same task queue
   // (MessageLoop); Quitting one RunLoop has no bearing on the others. Quit()
   // and QuitWhenIdle() can be called before, during or after Run(). If called
   // before Run(), Run() will return immediately when called. Calling Quit() or
   // QuitWhenIdle() after the RunLoop has already finished running has no
   // effect.
   //
   // WARNING: You must NEVER assume that a call to Quit() or QuitWhenIdle() will
   // terminate the targetted message loop. If a nested run loop continues
   // running, the target may NEVER terminate. It is very easy to livelock (run
   // forever) in such a case.
   void Quit();
   void QuitWhenIdle();
 
   // Convenience methods to get a closure that safely calls Quit() or
   // QuitWhenIdle() (has no effect if the RunLoop instance is gone).
   //
+  // The resulting Closure is thread-safe (note however that invoking the
+  // QuitClosure() from another thread than this RunLoop's will result in an
+  // asynchronous rather than immediate Quit()).
+  //
   // Example:
   //   RunLoop run_loop;
   //   PostTask(run_loop.QuitClosure());
   //   run_loop.Run();
   base::Closure QuitClosure();
   base::Closure QuitWhenIdleClosure();
 
   // Returns true if there is an active RunLoop on this thread.
   // Safe to call before RegisterDelegateForCurrentThread().
   static bool IsRunningOnCurrentThread();
@@ skipping 118 matching lines @@
 
   // Return false to abort the Run.
   bool BeforeRun();
   void AfterRun();
 
   // A copy of RunLoop::Delegate for the thread driven by tis RunLoop for quick
   // access without using TLS (also allows access to state from another sequence
   // during Run(), ref. |sequence_checker_| below).
   Delegate* delegate_;
 
+#if DCHECK_IS_ON()
   bool run_called_ = false;
+#endif
+
   bool quit_called_ = false;
   bool running_ = false;
-
   // Used to record that QuitWhenIdle() was called on the MessageLoop, meaning
   // that we should quit Run once it becomes idle.
   bool quit_when_idle_received_ = false;
 
-  // RunLoop is not thread-safe. Its state may not be accessed from any other
-  // sequence than the thread it was constructed on. Exception: RunLoop can be
-  // safely accessed from one other sequence (or single parallel task) during
-  // Run().
+  // RunLoop is not thread-safe. Its state/methods, unless marked as such, may
+  // not be accessed from any other sequence than the thread it was constructed
+  // on. Exception: RunLoop can be safely accessed from one other sequence (or
+  // single parallel task) during Run() -- e.g. to Quit() without having to
+  // plumb ThreatTaskRunnerHandle::Get() throughout a test to repost QuitClosure
+  // to origin thread.
   SEQUENCE_CHECKER(sequence_checker_);
 
+  const scoped_refptr<SingleThreadTaskRunner> origin_task_runner_;
+
   // WeakPtrFactory for QuitClosure safety.
   base::WeakPtrFactory<RunLoop> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RunLoop);
 };
 
 }  // namespace base
 
 #endif  // BASE_RUN_LOOP_H_