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

base/sequence_and_task_token.h

 // 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.
 
-#ifndef BASE_SEQUENCE_TOKEN_H_
-#define BASE_SEQUENCE_TOKEN_H_
+#ifndef BASE_SEQUENCE_AND_TASK_TOKEN_H_

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

Since TaskToken is more-or-less an implementation detail (i.e. not created by
users of the API and only used in ThreadCheckerImpl), is it really worth
renaming everything to expose its name in the public API?

It also makes things like ScopedSetSequenceAndTaskTokenForCurrentThread a
mouthful for no added readability IMO.

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

Done.

+#define BASE_SEQUENCE_AND_TASK_TOKEN_H_
 
 #include "base/base_export.h"
 #include "base/macros.h"
 
 namespace base {
 
 // A token that identifies a series of sequenced tasks (i.e. tasks that run one
 // at a time in posting order).
 class BASE_EXPORT SequenceToken {
  public:
@@ skipping 10 matching lines @@
   bool operator!=(const SequenceToken& other) const;
 
   // Returns true if this is a valid SequenceToken.
   bool IsValid() const;
 
   // Returns a valid SequenceToken which isn't equal to any previously returned
   // SequenceToken.
   static SequenceToken Create();
 
   // Returns the SequenceToken associated with the task running on the current
-  // thread, as determined by the active ScopedSetSequenceTokenForCurrentThread
-  // if any.
+  // thread, as determined by the active
+  // ScopedSetSequenceAndTaskTokenForCurrentThread if any.
   static SequenceToken GetForCurrentThread();
 
  private:
   SequenceToken(int token) : token_(token) {}
 
   static constexpr int kInvalidSequenceToken = -1;
   int token_ = kInvalidSequenceToken;
 };
 
-// Throughout its lifetime, determines the value returned by
-// SequenceToken::GetForCurrentThread().
-class BASE_EXPORT ScopedSetSequenceTokenForCurrentThread {
+// A token that identifies a task.

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

Expand comment to explain why this is necessary.

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

Done.

+class BASE_EXPORT TaskToken {
  public:
-  ScopedSetSequenceTokenForCurrentThread(const SequenceToken& token);
-  ~ScopedSetSequenceTokenForCurrentThread();
+  // Instantiates an invalid TaskToken.
+  TaskToken() = default;
+
+  // Explicitly allow copy.
+  TaskToken(const TaskToken& other) = default;
+  TaskToken& operator=(const TaskToken& other) = default;
+
+  // An invalid TaskToken is not equal to any other TaskToken, including
+  // other invalid TaskTokens.
+  bool operator==(const TaskToken& other) const;
+  bool operator!=(const TaskToken& other) const;
+
+  // Returns true if this is a valid TaskToken.
+  bool IsValid() const;
+
+  // Returns the TaskToken associated with the task running on the current
+  // thread, as determined by the active
+  // ScopedSetSequenceAndTaskTokenForCurrentThread if any.
+  static TaskToken GetForCurrentThread();
+
+ private:
+  friend class ScopedSetSequenceAndTaskTokenForCurrentThread;
+
+  TaskToken(int token) : token_(token) {}

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

Comment explaining why this is private (and also justifying friend decl)

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

Done.

+
+  // Returns a valid TaskToken which isn't equal to any previously returned
+  // TaskToken.
+  static TaskToken Create();
+
+  static constexpr int kInvalidTaskToken = -1;
+  int token_ = kInvalidTaskToken;
+};
+
+// Instantiate this in the scope where a single task runs.
+class BASE_EXPORT ScopedSetSequenceAndTaskTokenForCurrentThread {
+ public:
+  // Throughout the lifetime of the constructed object,
+  // SequenceToken::GetForCurrentThread() will return |sequence_token| and
+  // TaskToken::GetForCurrentThread() will return a TaskToken which is not equal
+  // to any TaskToken returned in the scope of another
+  // ScopedSetSequenceAndTaskTokenForCurrentThread.
+  ScopedSetSequenceAndTaskTokenForCurrentThread(
+      const SequenceToken& sequence_token);
+  ~ScopedSetSequenceAndTaskTokenForCurrentThread();
 
  private:
   friend class SequenceToken;
+  friend class TaskToken;

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

Cyclic-friending is weird, why is this needed?

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

ScopedSetSequenceTokenForCurrentThread needs to be able to call
TaskToken::Create(). I don't want to allow other callers.

TaskToken::GetForCurrentThread() has to get the current
ScopedSetSequenceTokenForCurrentThread and access it (private) task_token_
member to return it. I agree that this friend declaration wouldn't be needed if
I stored a pointer to the TaskToken and SequenceToken in TLS instead of a
pointer to the ScopedSetSequenceTokenForCurrentThread. I changed the code so
that these friend declarations are no longer needed.

 
-  const SequenceToken token_;
+  const SequenceToken sequence_token_;
+  const TaskToken task_token_;
 
-  DISALLOW_COPY_AND_ASSIGN(ScopedSetSequenceTokenForCurrentThread);
+  DISALLOW_COPY_AND_ASSIGN(ScopedSetSequenceAndTaskTokenForCurrentThread);
 };
 
 }  // namespace base
 
-#endif  // BASE_SEQUENCE_TOKEN_H_
+#endif  // BASE_SEQUENCE_AND_TASK_TOKEN_H_