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

base/threading/thread_checker_unittest.cc

Index: base/threading/thread_checker_unittest.cc
diff --git a/base/threading/thread_checker_unittest.cc b/base/threading/thread_checker_unittest.cc
index d806c0c75d308612c0c788ffa0f494c3b65b5b8b..26e863b4238d513d747a793c9ab3e29d99d47738 100644
--- a/base/threading/thread_checker_unittest.cc
+++ b/base/threading/thread_checker_unittest.cc
@@ -8,7 +8,7 @@
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/sequence_token.h"
+#include "base/sequence_and_task_token.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread_checker_impl.h"
@@ -62,49 +62,80 @@ void ExpectNotCalledOnValidThreadWithSequenceTokenAndThreadTaskRunnerHandle(
     SequenceToken sequence_token) {
   ThreadTaskRunnerHandle thread_task_runner_handle(
       make_scoped_refptr(new TestSimpleTaskRunner));
-  ScopedSetSequenceTokenForCurrentThread
-      scoped_set_sequence_token_for_current_thread(sequence_token);
+  ScopedSetSequenceAndTaskTokenForCurrentThread
+      scoped_set_sequence_and_task_token_for_current_thread(sequence_token);
   ExpectNotCalledOnValidThread(thread_checker);
 }
 
 }  // namespace
 
-TEST(ThreadCheckerTest, CallsAllowedSameThreadNoSequenceToken) {
+TEST(ThreadCheckerTest, AllowedSameThreadNoSequenceToken) {
   ThreadCheckerImpl thread_checker;
   EXPECT_TRUE(thread_checker.CalledOnValidThread());
 }
 
 TEST(ThreadCheckerTest,
-     CallsAllowedSameThreadSameSequenceTokenWithThreadTaskRunnerHandle) {
+     AllowedSameThreadAndSequenceDifferentTasksWithThreadTaskRunnerHandle) {
   ThreadTaskRunnerHandle thread_task_runner_handle(
       make_scoped_refptr(new TestSimpleTaskRunner));
-  ScopedSetSequenceTokenForCurrentThread
-      scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
+
+  std::unique_ptr<ThreadCheckerImpl> thread_checker;
+  const SequenceToken sequence_token = SequenceToken::Create();
+
+  {
+    ScopedSetSequenceAndTaskTokenForCurrentThread
+        scoped_set_sequence_and_task_token_for_current_thread(sequence_token);
+    thread_checker.reset(new ThreadCheckerImpl);
+  }
+
+  {
+    ScopedSetSequenceAndTaskTokenForCurrentThread
+        scoped_set_sequence_and_task_token_for_current_thread(sequence_token);
+    EXPECT_TRUE(thread_checker->CalledOnValidThread());
+  }
+}
+
+TEST(ThreadCheckerTest,
+     AllowedSameThreadSequenceAndTaskNoThreadTaskRunnerHandle) {
+  ScopedSetSequenceAndTaskTokenForCurrentThread
+      scoped_set_sequence_and_task_token_for_current_thread(
+          SequenceToken::Create());
   ThreadCheckerImpl thread_checker;
   EXPECT_TRUE(thread_checker.CalledOnValidThread());
 }
 
 TEST(ThreadCheckerTest,
-     CallsDisallowedSameThreadSameSequenceTokenNoThreadTaskRunnerHandle) {
-  ScopedSetSequenceTokenForCurrentThread
-      scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
-  ThreadCheckerImpl thread_checker;
-  EXPECT_FALSE(thread_checker.CalledOnValidThread());
+     DisallowedSameThreadAndSequenceDifferentTasksNoThreadTaskRunnerHandle) {
+  std::unique_ptr<ThreadCheckerImpl> thread_checker;
+
+  {
+    ScopedSetSequenceAndTaskTokenForCurrentThread
+        scoped_set_sequence_and_task_token_for_current_thread(
+            SequenceToken::Create());
+    thread_checker.reset(new ThreadCheckerImpl);
+  }
+
+  {
+    ScopedSetSequenceAndTaskTokenForCurrentThread
+        scoped_set_sequence_and_task_token_for_current_thread(
+            SequenceToken::Create());
+    EXPECT_FALSE(thread_checker->CalledOnValidThread());
+  }
 }
 
-TEST(ThreadCheckerTest, CallsDisallowedOnDifferentThreadsNoSequenceToken) {
+TEST(ThreadCheckerTest, DisallowedDifferentThreadsNoSequenceToken) {
   ThreadCheckerImpl thread_checker;
   RunCallbackOnNewThreadSynchronously(
       Bind(&ExpectNotCalledOnValidThread, Unretained(&thread_checker)));
 }
 
-TEST(ThreadCheckerTest, CallsDisallowedOnDifferentThreadsSameSequenceToken) {
+TEST(ThreadCheckerTest, DisallowedDifferentThreadsSameSequence) {
   ThreadTaskRunnerHandle thread_task_runner_handle(
       make_scoped_refptr(new TestSimpleTaskRunner));
   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);
   ThreadCheckerImpl thread_checker;
   EXPECT_TRUE(thread_checker.CalledOnValidThread());
 
@@ -113,22 +144,24 @@ TEST(ThreadCheckerTest, CallsDisallowedOnDifferentThreadsSameSequenceToken) {
       Unretained(&thread_checker), sequence_token));
 }
 
-TEST(ThreadCheckerTest, CallsDisallowedSameThreadDifferentSequenceToken) {
+TEST(ThreadCheckerTest, DisallowedSameThreadDifferentSequence) {
   std::unique_ptr<ThreadCheckerImpl> thread_checker;
 
   ThreadTaskRunnerHandle thread_task_runner_handle(
       make_scoped_refptr(new TestSimpleTaskRunner));
 
   {
-    ScopedSetSequenceTokenForCurrentThread
-        scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
+    ScopedSetSequenceAndTaskTokenForCurrentThread
+        scoped_set_sequence_and_task_token_for_current_thread(
+            SequenceToken::Create());
     thread_checker.reset(new ThreadCheckerImpl);
   }
 
   {
     // 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(thread_checker->CalledOnValidThread());
   }
 
@@ -151,8 +184,9 @@ TEST(ThreadCheckerTest, DetachFromThread) {
 TEST(ThreadCheckerTest, DetachFromThreadWithSequenceToken) {
   ThreadTaskRunnerHandle thread_task_runner_handle(
       make_scoped_refptr(new TestSimpleTaskRunner));
-  ScopedSetSequenceTokenForCurrentThread
-      scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
+  ScopedSetSequenceAndTaskTokenForCurrentThread
+      scoped_set_sequence_and_task_token_for_current_thread(
+          SequenceToken::Create());
   ThreadCheckerImpl thread_checker;
   thread_checker.DetachFromThread();