Make ThreadChecker::CalledOnValidThread() return true when called from the same task.

base/sequence_checker_unittest.cc

 // Copyright 2013 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 <stddef.h>
 
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
+#include "base/sequence_and_task_token.h"
 #include "base/sequence_checker_impl.h"
-#include "base/sequence_token.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "base/threading/simple_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 namespace {
 
 constexpr size_t kNumWorkerThreads = 3;
@@ skipping 45 matching lines @@
   EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
 
   // Since |sequence_checker| is now bound to the current sequence, another call
   // to CalledOnValidSequence() should return true.
   EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
 }
 
 void ExpectCalledOnValidSequenceWithSequenceToken(
     SequenceCheckerImpl* sequence_checker,
     SequenceToken sequence_token) {
-  ScopedSetSequenceTokenForCurrentThread
-      scoped_set_sequence_token_for_current_thread(sequence_token);
+  ScopedSetSequenceAndTaskTokenForCurrentThread
+      scoped_set_sequence_and_task_token_for_current_thread(sequence_token);
   ExpectCalledOnValidSequence(sequence_checker);
 }
 
 void ExpectNotCalledOnValidSequence(SequenceCheckerImpl* sequence_checker) {
   ASSERT_TRUE(sequence_checker);
   EXPECT_FALSE(sequence_checker->CalledOnValidSequence());
 }
 
 }  // namespace
 
 TEST_F(SequenceCheckerTest, CallsAllowedOnSameThreadNoSequenceToken) {
   SequenceCheckerImpl sequence_checker;
   EXPECT_TRUE(sequence_checker.CalledOnValidSequence());
 }
 
 TEST_F(SequenceCheckerTest, CallsAllowedOnSameThreadSameSequenceToken) {
-  ScopedSetSequenceTokenForCurrentThread
-      scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
+  ScopedSetSequenceAndTaskTokenForCurrentThread
+      scoped_set_sequence_and_task_token_for_current_thread(
+          SequenceToken::Create());
   SequenceCheckerImpl sequence_checker;
   EXPECT_TRUE(sequence_checker.CalledOnValidSequence());
 }
 
 TEST_F(SequenceCheckerTest, CallsDisallowedOnDifferentThreadsNoSequenceToken) {
   SequenceCheckerImpl sequence_checker;
   RunCallbackThread thread(
       Bind(&ExpectNotCalledOnValidSequence, Unretained(&sequence_checker)));
 }
 
 TEST_F(SequenceCheckerTest, CallsAllowedOnDifferentThreadsSameSequenceToken) {
   const SequenceToken sequence_token(SequenceToken::Create());
 
-  ScopedSetSequenceTokenForCurrentThread
-      scoped_set_sequence_token_for_current_thread(sequence_token);
+  ScopedSetSequenceAndTaskTokenForCurrentThread
+      scoped_set_sequence_and_task_token_for_current_thread(sequence_token);
   SequenceCheckerImpl sequence_checker;
   EXPECT_TRUE(sequence_checker.CalledOnValidSequence());
 
   RunCallbackThread thread(Bind(&ExpectCalledOnValidSequenceWithSequenceToken,
                                 Unretained(&sequence_checker), sequence_token));
 }
 
 TEST_F(SequenceCheckerTest, CallsDisallowedOnSameThreadDifferentSequenceToken) {
   std::unique_ptr<SequenceCheckerImpl> sequence_checker;
 
   {
-    ScopedSetSequenceTokenForCurrentThread
-        scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
+    ScopedSetSequenceAndTaskTokenForCurrentThread
+        scoped_set_sequence_and_task_token_for_current_thread(
+            SequenceToken::Create());
     sequence_checker.reset(new SequenceCheckerImpl);
   }
 
   {
     // Different SequenceToken.
-    ScopedSetSequenceTokenForCurrentThread
-        scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
+    ScopedSetSequenceAndTaskTokenForCurrentThread
+        scoped_set_sequence_and_task_token_for_current_thread(
+            SequenceToken::Create());
     EXPECT_FALSE(sequence_checker->CalledOnValidSequence());
   }
 
   // No SequenceToken.
   EXPECT_FALSE(sequence_checker->CalledOnValidSequence());
 }
 
 TEST_F(SequenceCheckerTest, DetachFromSequence) {
   std::unique_ptr<SequenceCheckerImpl> sequence_checker;
 
   {
-    ScopedSetSequenceTokenForCurrentThread
-        scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
+    ScopedSetSequenceAndTaskTokenForCurrentThread
+        scoped_set_sequence_and_task_token_for_current_thread(
+            SequenceToken::Create());
     sequence_checker.reset(new SequenceCheckerImpl);
   }
 
   sequence_checker->DetachFromSequence();
 
   {
     // Verify that CalledOnValidSequence() returns true when called with
     // a different sequence token after a call to DetachFromSequence().
-    ScopedSetSequenceTokenForCurrentThread
-        scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
+    ScopedSetSequenceAndTaskTokenForCurrentThread
+        scoped_set_sequence_and_task_token_for_current_thread(
+            SequenceToken::Create());
     EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
   }
 }
 
 TEST_F(SequenceCheckerTest, DetachFromSequenceNoSequenceToken) {
   SequenceCheckerImpl sequence_checker;
   sequence_checker.DetachFromSequence();
 
   // Verify that CalledOnValidSequence() returns true when called on a
   // different thread after a call to DetachFromSequence().
@@ skipping 79 matching lines @@
   FlushSequencedWorkerPoolForTesting();
 
   SequencedWorkerPoolOwner second_pool_owner(kNumWorkerThreads, "test2");
   second_pool_owner.pool()->PostNamedSequencedWorkerTask(
       "A", FROM_HERE, base::Bind(&ExpectNotCalledOnValidSequence,
                                  base::Unretained(&sequence_checker)));
   second_pool_owner.pool()->FlushForTesting();
 }
 
 }  // namespace base