Rename CalledOnValidSequencedThread() to CalledOnValidSequence().

base/threading/thread.cc

 // 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.
 
 #include "base/threading/thread.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
@@ skipping 42 matching lines @@
   // another sequence as long as every other operation is then performed on that
   // sequence.
   owning_sequence_checker_.DetachFromSequence();
 }
 
 Thread::~Thread() {
   Stop();
 }
 
 bool Thread::Start() {
-  DCHECK(owning_sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(owning_sequence_checker_.CalledOnValidSequence());
 
   Options options;
 #if defined(OS_WIN)
   if (com_status_ == STA)
     options.message_loop_type = MessageLoop::TYPE_UI;
 #endif
   return StartWithOptions(options);
 }
 
 bool Thread::StartWithOptions(const Options& options) {
-  DCHECK(owning_sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(owning_sequence_checker_.CalledOnValidSequence());
   DCHECK(!message_loop_);
   DCHECK(!IsRunning());
 #if defined(OS_WIN)
   DCHECK((com_status_ != STA) ||
       (options.message_loop_type == MessageLoop::TYPE_UI));
 #endif
 
   // Reset |id_| here to support restarting the thread.
   id_event_.Reset();
   id_ = kInvalidThreadId;
@@ skipping 25 matching lines @@
 
   // The ownership of |message_loop_| is managed by the newly created thread
   // within the ThreadMain.
   ignore_result(message_loop_owned.release());
 
   DCHECK(message_loop_);
   return true;
 }
 
 bool Thread::StartAndWaitForTesting() {
-  DCHECK(owning_sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(owning_sequence_checker_.CalledOnValidSequence());
   bool result = Start();
   if (!result)
     return false;
   WaitUntilThreadStarted();
   return true;
 }
 
 bool Thread::WaitUntilThreadStarted() const {
-  DCHECK(owning_sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(owning_sequence_checker_.CalledOnValidSequence());
   if (!message_loop_)
     return false;
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   start_event_.Wait();
   return true;
 }
 
 void Thread::Stop() {
   // TODO(gab): Fix improper usage of this API (http://crbug.com/629139) and
   // enable this check, until then synchronization with Start() via
   // |thread_lock_| is required...
-  // DCHECK(owning_sequence_checker_.CalledOnValidSequencedThread());
+  // DCHECK(owning_sequence_checker_.CalledOnValidSequence());
   AutoLock lock(thread_lock_);
 
   if (thread_.is_null())
     return;
 
   StopSoon();
 
   // Wait for the thread to exit.
   //
   // TODO(darin): Unfortunately, we need to keep |message_loop_| around until
   // the thread exits.  Some consumers are abusing the API.  Make them stop.
   //
   PlatformThread::Join(thread_);
   thread_ = base::PlatformThreadHandle();
 
   // The thread should nullify |message_loop_| on exit (note: Join() adds an
   // implicit memory barrier and no lock is thus required for this check).
   DCHECK(!message_loop_);
 
   stopping_ = false;
 }
 
 void Thread::StopSoon() {
   // TODO(gab): Fix improper usage of this API (http://crbug.com/629139) and
   // enable this check.
-  // DCHECK(owning_sequence_checker_.CalledOnValidSequencedThread());
+  // DCHECK(owning_sequence_checker_.CalledOnValidSequence());
 
   if (stopping_ || !message_loop_)
     return;
 
   stopping_ = true;
   task_runner()->PostTask(
       FROM_HERE, base::Bind(&Thread::ThreadQuitHelper, Unretained(this)));
 }
 
 PlatformThreadId Thread::GetThreadId() const {
   // If the thread is created but not started yet, wait for |id_| being ready.
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   id_event_.Wait();
   return id_;
 }
 
 bool Thread::IsRunning() const {
   // TODO(gab): Fix improper usage of this API (http://crbug.com/629139) and
   // enable this check.
-  // DCHECK(owning_sequence_checker_.CalledOnValidSequencedThread());
+  // DCHECK(owning_sequence_checker_.CalledOnValidSequence());
 
   // If the thread's already started (i.e. |message_loop_| is non-null) and not
   // yet requested to stop (i.e. |stopping_| is false) we can just return true.
   // (Note that |stopping_| is touched only on the same sequence that starts /
   // started the new thread so we need no locking here.)
   if (message_loop_ && !stopping_)
     return true;
   // Otherwise check the |running_| flag, which is set to true by the new thread
   // only while it is inside Run().
   AutoLock lock(running_lock_);
@@ skipping 86 matching lines @@
   run_loop_ = nullptr;
 }
 
 void Thread::ThreadQuitHelper() {
   DCHECK(run_loop_);
   run_loop_->QuitWhenIdle();
   SetThreadWasQuitProperly(true);
 }
 
 }  // namespace base