Loosen thread-safety checks and update documentation on RunLoop.

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/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;
@@ skipping 18 matching lines @@
   // MessageLoop...), but those are deprecated.
   void Run();
 
   // Run the current RunLoop::Delegate until it doesn't find any tasks or
   // messages in its queue (it goes idle). WARNING: This may never return! Only
   // use this when repeating tasks such as animated web pages have been shut
   // down.
   void RunUntilIdle();
 
   bool running() const {
-    // TODO(gab): Fix bad usage and enable this check, http://crbug.com/715235.
-    // DCHECK(thread_checker_.CalledOnValidThread());
+    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.
   //
   // 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
@@ skipping 102 matching lines @@
     using RunLoopStack = std::stack<RunLoop*, std::vector<RunLoop*>>;
 
     bool allow_nesting_ = true;
     RunLoopStack active_run_loops_;
     ObserverList<RunLoop::NestingObserver> nesting_observers_;
 
     // True once this Delegate is bound to a thread via
     // RegisterDelegateForCurrentThread().
     bool bound_ = false;
 
+    // Thread-affine per its use of TLS.
     THREAD_CHECKER(bound_thread_checker_);
 
     Client client_interface_ = Client(this);
 
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // Registers |delegate| on the current thread. Must be called once and only
   // once per thread before using RunLoop methods on it. |delegate| is from then
   // on forever bound to that thread (including its destruction). The returned
@@ skipping 13 matching lines @@
 #if defined(OS_IOS)
   // iOS doesn't support the blocking MessageLoop::Run, so it calls
   // BeforeRun directly.
   friend class base::MessagePumpUIApplication;
 #endif
 
   // Return false to abort the Run.
   bool BeforeRun();
   void AfterRun();
 
-  // A copy of RunLoop::Delegate for this thread for quick access without using
-  // TLS.
+  // 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_;
 
   bool run_called_ = false;
   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's non-static methods are affine to the thread it's running on per
-  // this class' underlying use of thread-local-storage.
-  base::ThreadChecker thread_checker_;
+  // 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().
+  SEQUENCE_CHECKER(sequence_checker_);
 
   // WeakPtrFactory for QuitClosure safety.
   base::WeakPtrFactory<RunLoop> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RunLoop);
 };
 
 }  // namespace base
 
 #endif  // BASE_RUN_LOOP_H_