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

base/sequence_and_task_token_unittest.cc

 // Copyright 2016 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/sequence_token.h"
+#include "base/sequence_and_task_token.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 TEST(SequenceTokenTest, IsValid) {
   EXPECT_FALSE(SequenceToken().IsValid());
   EXPECT_TRUE(SequenceToken::Create().IsValid());
 }
 
@@ skipping 30 matching lines @@
   EXPECT_FALSE(valid_a != valid_a);
   EXPECT_NE(valid_a, valid_b);
 }
 
 TEST(SequenceTokenTest, GetForCurrentThread) {
   const SequenceToken token = SequenceToken::Create();
 
   EXPECT_FALSE(SequenceToken::GetForCurrentThread().IsValid());
 
   {
-    ScopedSetSequenceTokenForCurrentThread
-        scoped_set_sequence_token_for_current_thread(token);
+    ScopedSetSequenceAndTaskTokenForCurrentThread
+        scoped_set_sequence_and_task_token_for_current_thread(token);
     EXPECT_TRUE(SequenceToken::GetForCurrentThread().IsValid());
     EXPECT_EQ(token, SequenceToken::GetForCurrentThread());
   }
 
   EXPECT_FALSE(SequenceToken::GetForCurrentThread().IsValid());
 }
 
+// Expect a default-constructed TaskToken to be invalid and not equal to
+// another invalid TaskToken.
+TEST(TaskTokenTest, InvalidDefaultConstructed) {
+  EXPECT_FALSE(TaskToken().IsValid());
+  EXPECT_NE(TaskToken(), TaskToken());
+}
+
+// Expect a TaskToken returned by TaskToken::GetForCurrentThread() outside the
+// scope of a ScopedSetSequenceAndTaskTokenForCurrentThread to be invalid.
+TEST(TaskTokenTest, InvalidOutsideScope) {
+  EXPECT_FALSE(TaskToken::GetForCurrentThread().IsValid());
+}
+
+// Expect TaskTokens returned by TaskToken::GetForCurrentThread() in the scope
+// of the same ScopedSetSequenceAndTaskTokenForCurrentThread instance to be
+// valid and equal with each other, but not equal to an invalid TaskToken.

[gab, 2016/08/08 16:34:22]

"but not equal to an invalid TaskToken" -- isn't this overkill since invalid
tokens aren't equal?

[fdoray, 2016/08/08 17:45:18]

Done.

+TEST(TaskTokenTest, EqualInSameScope) {
+  ScopedSetSequenceAndTaskTokenForCurrentThread
+      scoped_set_sequence_and_task_token_for_current_thread(
+          SequenceToken::Create());
+
+  const TaskToken token_a = TaskToken::GetForCurrentThread();
+  const TaskToken token_b = TaskToken::GetForCurrentThread();
+
+  EXPECT_TRUE(token_a.IsValid());
+  EXPECT_TRUE(token_b.IsValid());
+
+  EXPECT_EQ(token_a, token_b);
+  EXPECT_NE(token_a, TaskToken());
+  EXPECT_NE(token_b, TaskToken());

[gab, 2016/08/08 16:34:22]

rm last two conditions IMO per above comment 

[fdoray, 2016/08/08 17:45:18]

Done.

+}
+
+// Expect TaskTokens returned by TaskToken::GetForCurrentThread() in the scope
+// of different ScopedSetSequenceAndTaskTokenForCurrentThread instances to be
+// valid but not equal to each other or to an invalid TaskToken.
+TEST(TaskTokenTest, NotEqualInDifferentScopes) {
+  TaskToken token_a;
+  TaskToken token_b;
+
+  {
+    ScopedSetSequenceAndTaskTokenForCurrentThread
+        scoped_set_sequence_and_task_token_for_current_thread(
+            SequenceToken::Create());
+    token_a = TaskToken::GetForCurrentThread();
+  }
+  {
+    ScopedSetSequenceAndTaskTokenForCurrentThread
+        scoped_set_sequence_and_task_token_for_current_thread(
+            SequenceToken::Create());
+    token_b = TaskToken::GetForCurrentThread();
+  }
+
+  EXPECT_TRUE(token_a.IsValid());
+  EXPECT_TRUE(token_b.IsValid());
+
+  EXPECT_NE(token_a, token_b);
+  EXPECT_NE(token_a, TaskToken());
+  EXPECT_NE(token_b, TaskToken());

[gab, 2016/08/08 16:34:22]

ditto

[fdoray, 2016/08/08 17:45:18]

Done.

+}
+
 }  // namespace base