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

base/sequence_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_
 
 #include "base/base_export.h"
 #include "base/macros.h"
 
@@ skipping 27 matching lines @@
   // 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().
+// A token that identifies a task.
+//
+// This is used by ThreadCheckerImpl to determine whether calls to
+// CalledOnValidThread() come from the same task and hence are deterministically
+// single-threaded (vs. calls coming from different sequenced or parallel tasks,
+// which may or may not run on the same thread).
+class BASE_EXPORT TaskToken {
+ public:
+  // 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;
+
+  // In the scope of a ScopedSetSequenceTokenForCurrentThread, returns a valid
+  // TaskToken which isn't equal to any TaskToken returned in the scope of a
+  // different ScopedSetSequenceTokenForCurrentThread. Otherwise, returns an
+  // invalid TaskToken.
+  static TaskToken GetForCurrentThread();
+
+ private:
+  friend class ScopedSetSequenceTokenForCurrentThread;
+
+  TaskToken(int token) : token_(token) {}
+
+  // Returns a valid TaskToken which isn't equal to any previously returned
+  // TaskToken. This is private to ensure that a TaskToken is only created when
+  // a ScopedSetSequenceTokenForCurrentThread is instantiated.

[gab, 2016/08/08 17:56:35]

How about "This is private as it only meant to be instantiated by
ScopedSetSequenceTokenForCurrentThread."

[fdoray, 2016/08/08 18:11:35]

Done.

+  static TaskToken Create();
+
+  static constexpr int kInvalidTaskToken = -1;
+  int token_ = kInvalidTaskToken;
+};
+
+// Instantiate this in the scope where a single task runs.
 class BASE_EXPORT ScopedSetSequenceTokenForCurrentThread {
  public:
-  ScopedSetSequenceTokenForCurrentThread(const SequenceToken& token);
+  // 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
+  // ScopedSetSequenceTokenForCurrentThread.
+  ScopedSetSequenceTokenForCurrentThread(const SequenceToken& sequence_token);
   ~ScopedSetSequenceTokenForCurrentThread();
 
  private:
-  friend class SequenceToken;
-
-  const SequenceToken token_;
+  const SequenceToken sequence_token_;
+  const TaskToken task_token_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedSetSequenceTokenForCurrentThread);
 };
 
 }  // namespace base
 
 #endif  // BASE_SEQUENCE_TOKEN_H_