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

base/threading/thread_checker_unittest.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 <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 51 matching lines @@
     SequenceToken sequence_token) {
   ThreadTaskRunnerHandle thread_task_runner_handle(
       make_scoped_refptr(new TestSimpleTaskRunner));
   ScopedSetSequenceTokenForCurrentThread
       scoped_set_sequence_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));
+
+  std::unique_ptr<ThreadCheckerImpl> thread_checker;
+  const SequenceToken sequence_token = SequenceToken::Create();
+
+  {
+    ScopedSetSequenceTokenForCurrentThread
+        scoped_set_sequence_token_for_current_thread(sequence_token);
+    thread_checker.reset(new ThreadCheckerImpl);
+  }
+
+  {
+    ScopedSetSequenceTokenForCurrentThread
+        scoped_set_sequence_token_for_current_thread(sequence_token);
+    EXPECT_TRUE(thread_checker->CalledOnValidThread());
+  }
+}
+
+TEST(ThreadCheckerTest,
+     AllowedSameThreadSequenceAndTaskNoThreadTaskRunnerHandle) {
   ScopedSetSequenceTokenForCurrentThread
       scoped_set_sequence_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;
+
+  {
+    ScopedSetSequenceTokenForCurrentThread
+        scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
+    thread_checker.reset(new ThreadCheckerImpl);
+  }
+
+  {
+    ScopedSetSequenceTokenForCurrentThread
+        scoped_set_sequence_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);
   ThreadCheckerImpl thread_checker;
   EXPECT_TRUE(thread_checker.CalledOnValidThread());
 
   RunCallbackOnNewThreadSynchronously(Bind(
       &ExpectNotCalledOnValidThreadWithSequenceTokenAndThreadTaskRunnerHandle,
       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());
     thread_checker.reset(new ThreadCheckerImpl);
   }
@@ skipping 31 matching lines @@
 
   // Verify that CalledOnValidThread() returns true when called on a different
   // thread after a call to DetachFromThread().
   RunCallbackOnNewThreadSynchronously(
       Bind(&ExpectCalledOnValidThread, Unretained(&thread_checker)));
 
   EXPECT_FALSE(thread_checker.CalledOnValidThread());
 }
 
 }  // namespace base