Ensure that |Thread::id_| is only accessed when an happens-after relationship has been established …

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>
@@ skipping 171 matching lines @@
     // never sees it before it's set). In practice, many callers are coming from
     // unrelated threads but provide their own implicit (e.g. memory barriers
     // from task posting) or explicit (e.g. locks) synchronization making the
     // access of |message_loop_| safe... Changing all of those callers is
     // unfeasible; instead verify that they can reliably see
     // |message_loop_ != nullptr| without synchronization as a proof that their
     // external synchronization catches the unsynchronized effects of Start().
     // TODO(gab): Despite all of the above this test has to be disabled for now
     // per crbug.com/629139#c6.
     // DCHECK(owning_sequence_checker_.CalledOnValidSequence() ||
-    //        id_ == PlatformThread::CurrentId() || message_loop_)
-    //     << id_ << " vs " << PlatformThread::CurrentId();
+    //        (id_event_.IsSignaled() && id_ == PlatformThread::CurrentId()) ||
+    //        message_loop_);
     return message_loop_;
   }
 
   // Returns a TaskRunner for this thread. Use the TaskRunner's PostTask
   // methods to execute code on the thread. Returns nullptr if the thread is not
   // running (e.g. before Start or after Stop have been called). Callers can
   // hold on to this even after the thread is gone; in this situation, attempts
   // to PostTask() will fail.
   //
   // In addition to this Thread's owning sequence, this can also safely be
   // called from the underlying thread itself.
   scoped_refptr<SingleThreadTaskRunner> task_runner() const {
     // Refer to the DCHECK and comment inside |message_loop()|.
     DCHECK(owning_sequence_checker_.CalledOnValidSequence() ||
-           id_ == PlatformThread::CurrentId() || message_loop_)
-        << id_ << " vs " << PlatformThread::CurrentId();
+           (id_event_.IsSignaled() && id_ == PlatformThread::CurrentId()) ||
+           message_loop_);
     return message_loop_ ? message_loop_->task_runner() : nullptr;
   }
 
   // Returns the name of this thread (for display in debugger too).
   const std::string& thread_name() const { return name_; }
 
   // Returns the thread ID.  Should not be called before the first Start*()
   // call.  Keeps on returning the same ID even after a Stop() call. The next
   // Start*() call renews the ID.
   //
@@ skipping 53 matching lines @@
   // True while inside of Run().
   bool running_ = false;
   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_ = kInvalidThreadId;
-  mutable WaitableEvent id_event_;  // Protects |id_|.
+  // Protects |id_| which must only be read while it's signaled.
+  mutable WaitableEvent id_event_;
 
   // The thread's MessageLoop and RunLoop. Valid only while the thread is alive.
   // Set by the created thread.
   MessageLoop* message_loop_ = nullptr;
   RunLoop* run_loop_ = nullptr;
 
   // True only if |message_loop_| was externally provided by |SetMessageLoop()|
   // in which case this Thread has no underlying |thread_| and should merely
   // drop |message_loop_| on Stop().
   bool using_external_message_loop_ = false;
@@ skipping 11 matching lines @@
   // This class is not thread-safe, use this to verify access from the owning
   // sequence of the Thread.
   SequenceChecker owning_sequence_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_THREAD_H_