sequence_checker_unittest.cc 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285
  1. // Copyright 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "base/sequence_checker.h"
  5. #include <stddef.h>
  6. #include <memory>
  7. #include <string>
  8. #include <utility>
  9. #include "base/bind.h"
  10. #include "base/callback_helpers.h"
  11. #include "base/sequence_token.h"
  12. #include "base/task/single_thread_task_runner.h"
  13. #include "base/task/thread_pool.h"
  14. #include "base/test/bind.h"
  15. #include "base/test/gtest_util.h"
  16. #include "base/test/task_environment.h"
  17. #include "base/threading/simple_thread.h"
  18. #include "base/threading/thread_local.h"
  19. #include "testing/gtest/include/gtest/gtest.h"
  20. namespace base {
  21. namespace {
  22. // Runs a callback on another thread.
  23. class RunCallbackThread : public SimpleThread {
  24. public:
  25. explicit RunCallbackThread(OnceClosure callback)
  26. : SimpleThread("RunCallbackThread"), callback_(std::move(callback)) {
  27. Start();
  28. Join();
  29. }
  30. RunCallbackThread(const RunCallbackThread&) = delete;
  31. RunCallbackThread& operator=(const RunCallbackThread&) = delete;
  32. private:
  33. // SimpleThread:
  34. void Run() override { std::move(callback_).Run(); }
  35. OnceClosure callback_;
  36. };
  37. void ExpectCalledOnValidSequence(SequenceCheckerImpl* sequence_checker) {
  38. ASSERT_TRUE(sequence_checker);
  39. // This should bind |sequence_checker| to the current sequence if it wasn't
  40. // already bound to a sequence.
  41. EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
  42. // Since |sequence_checker| is now bound to the current sequence, another call
  43. // to CalledOnValidSequence() should return true.
  44. EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
  45. }
  46. void ExpectCalledOnValidSequenceWithSequenceToken(
  47. SequenceCheckerImpl* sequence_checker,
  48. SequenceToken sequence_token) {
  49. ScopedSetSequenceTokenForCurrentThread
  50. scoped_set_sequence_token_for_current_thread(sequence_token);
  51. ExpectCalledOnValidSequence(sequence_checker);
  52. }
  53. void ExpectNotCalledOnValidSequence(SequenceCheckerImpl* sequence_checker) {
  54. ASSERT_TRUE(sequence_checker);
  55. EXPECT_FALSE(sequence_checker->CalledOnValidSequence());
  56. }
  57. } // namespace
  58. TEST(SequenceCheckerTest, CallsAllowedOnSameThreadNoSequenceToken) {
  59. SequenceCheckerImpl sequence_checker;
  60. EXPECT_TRUE(sequence_checker.CalledOnValidSequence());
  61. }
  62. TEST(SequenceCheckerTest, CallsAllowedOnSameThreadSameSequenceToken) {
  63. ScopedSetSequenceTokenForCurrentThread
  64. scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
  65. SequenceCheckerImpl sequence_checker;
  66. EXPECT_TRUE(sequence_checker.CalledOnValidSequence());
  67. }
  68. TEST(SequenceCheckerTest, CallsDisallowedOnDifferentThreadsNoSequenceToken) {
  69. SequenceCheckerImpl sequence_checker;
  70. RunCallbackThread thread(
  71. BindOnce(&ExpectNotCalledOnValidSequence, Unretained(&sequence_checker)));
  72. }
  73. TEST(SequenceCheckerTest, CallsAllowedOnDifferentThreadsSameSequenceToken) {
  74. const SequenceToken sequence_token(SequenceToken::Create());
  75. ScopedSetSequenceTokenForCurrentThread
  76. scoped_set_sequence_token_for_current_thread(sequence_token);
  77. SequenceCheckerImpl sequence_checker;
  78. EXPECT_TRUE(sequence_checker.CalledOnValidSequence());
  79. RunCallbackThread thread(
  80. BindOnce(&ExpectCalledOnValidSequenceWithSequenceToken,
  81. Unretained(&sequence_checker), sequence_token));
  82. }
  83. TEST(SequenceCheckerTest, CallsDisallowedOnSameThreadDifferentSequenceToken) {
  84. std::unique_ptr<SequenceCheckerImpl> sequence_checker;
  85. {
  86. ScopedSetSequenceTokenForCurrentThread
  87. scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
  88. sequence_checker = std::make_unique<SequenceCheckerImpl>();
  89. }
  90. {
  91. // Different SequenceToken.
  92. ScopedSetSequenceTokenForCurrentThread
  93. scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
  94. EXPECT_FALSE(sequence_checker->CalledOnValidSequence());
  95. }
  96. // No SequenceToken.
  97. EXPECT_FALSE(sequence_checker->CalledOnValidSequence());
  98. }
  99. TEST(SequenceCheckerTest, DetachFromSequence) {
  100. std::unique_ptr<SequenceCheckerImpl> sequence_checker;
  101. {
  102. ScopedSetSequenceTokenForCurrentThread
  103. scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
  104. sequence_checker = std::make_unique<SequenceCheckerImpl>();
  105. }
  106. sequence_checker->DetachFromSequence();
  107. {
  108. // Verify that CalledOnValidSequence() returns true when called with
  109. // a different sequence token after a call to DetachFromSequence().
  110. ScopedSetSequenceTokenForCurrentThread
  111. scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
  112. EXPECT_TRUE(sequence_checker->CalledOnValidSequence());
  113. }
  114. }
  115. TEST(SequenceCheckerTest, DetachFromSequenceNoSequenceToken) {
  116. SequenceCheckerImpl sequence_checker;
  117. sequence_checker.DetachFromSequence();
  118. // Verify that CalledOnValidSequence() returns true when called on a
  119. // different thread after a call to DetachFromSequence().
  120. RunCallbackThread thread(
  121. BindOnce(&ExpectCalledOnValidSequence, Unretained(&sequence_checker)));
  122. EXPECT_FALSE(sequence_checker.CalledOnValidSequence());
  123. }
  124. TEST(SequenceCheckerTest, Move) {
  125. SequenceCheckerImpl initial;
  126. EXPECT_TRUE(initial.CalledOnValidSequence());
  127. SequenceCheckerImpl move_constructed(std::move(initial));
  128. EXPECT_TRUE(move_constructed.CalledOnValidSequence());
  129. SequenceCheckerImpl move_assigned;
  130. move_assigned = std::move(move_constructed);
  131. // The two SequenceCheckerImpls moved from should be able to rebind to another
  132. // sequence.
  133. RunCallbackThread thread1(
  134. BindOnce(&ExpectCalledOnValidSequence, Unretained(&initial)));
  135. RunCallbackThread thread2(
  136. BindOnce(&ExpectCalledOnValidSequence, Unretained(&move_constructed)));
  137. // But the latest one shouldn't be able to run on another sequence.
  138. RunCallbackThread thread(
  139. BindOnce(&ExpectNotCalledOnValidSequence, Unretained(&move_assigned)));
  140. EXPECT_TRUE(move_assigned.CalledOnValidSequence());
  141. }
  142. TEST(SequenceCheckerTest, MoveAssignIntoDetached) {
  143. SequenceCheckerImpl initial;
  144. SequenceCheckerImpl move_assigned;
  145. move_assigned.DetachFromSequence();
  146. move_assigned = std::move(initial);
  147. // |initial| is detached after move.
  148. RunCallbackThread thread1(
  149. BindOnce(&ExpectCalledOnValidSequence, Unretained(&initial)));
  150. // |move_assigned| should be associated with the main thread.
  151. RunCallbackThread thread2(
  152. BindOnce(&ExpectNotCalledOnValidSequence, Unretained(&move_assigned)));
  153. EXPECT_TRUE(move_assigned.CalledOnValidSequence());
  154. }
  155. TEST(SequenceCheckerTest, MoveFromDetachedRebinds) {
  156. SequenceCheckerImpl initial;
  157. initial.DetachFromSequence();
  158. SequenceCheckerImpl moved_into(std::move(initial));
  159. // |initial| is still detached after move.
  160. RunCallbackThread thread1(
  161. BindOnce(&ExpectCalledOnValidSequence, Unretained(&initial)));
  162. // |moved_into| is bound to the current sequence as part of the move.
  163. RunCallbackThread thread2(
  164. BindOnce(&ExpectNotCalledOnValidSequence, Unretained(&moved_into)));
  165. EXPECT_TRUE(moved_into.CalledOnValidSequence());
  166. }
  167. TEST(SequenceCheckerTest, MoveOffSequenceBanned) {
  168. testing::GTEST_FLAG(death_test_style) = "threadsafe";
  169. SequenceCheckerImpl other_sequence;
  170. other_sequence.DetachFromSequence();
  171. RunCallbackThread thread(
  172. BindOnce(&ExpectCalledOnValidSequence, Unretained(&other_sequence)));
  173. EXPECT_DCHECK_DEATH(
  174. SequenceCheckerImpl main_sequence(std::move(other_sequence)));
  175. }
  176. TEST(SequenceCheckerMacroTest, Macros) {
  177. auto scope = std::make_unique<ScopedSetSequenceTokenForCurrentThread>(
  178. SequenceToken::Create());
  179. SEQUENCE_CHECKER(my_sequence_checker);
  180. {
  181. // Don't expect a DCHECK death when a SequenceChecker is used on the right
  182. // sequence.
  183. DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker);
  184. }
  185. scope.reset();
  186. #if DCHECK_IS_ON()
  187. // Expect DCHECK death when used on a different sequence.
  188. EXPECT_DCHECK_DEATH(
  189. { DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker); });
  190. #else
  191. // Happily no-ops on non-dcheck builds.
  192. DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker);
  193. #endif
  194. DETACH_FROM_SEQUENCE(my_sequence_checker);
  195. // Don't expect a DCHECK death when a SequenceChecker is used for the first
  196. // time after having been detached.
  197. DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker);
  198. }
  199. // Owns a SequenceCheckerImpl, and asserts that CalledOnValidSequence() is valid
  200. // in ~SequenceCheckerOwner.
  201. class SequenceCheckerOwner {
  202. public:
  203. SequenceCheckerOwner() = default;
  204. SequenceCheckerOwner(const SequenceCheckerOwner&) = delete;
  205. SequenceCheckerOwner& operator=(const SequenceCheckerOwner&) = delete;
  206. ~SequenceCheckerOwner() { EXPECT_TRUE(checker_.CalledOnValidSequence()); }
  207. private:
  208. SequenceCheckerImpl checker_;
  209. };
  210. // Verifies SequenceCheckerImpl::CalledOnValidSequence() returns true if called
  211. // during thread destruction.
  212. TEST(SequenceCheckerTest, CalledOnValidSequenceFromThreadDestruction) {
  213. SequenceChecker::EnableStackLogging();
  214. ThreadLocalOwnedPointer<SequenceCheckerOwner> thread_local_owner;
  215. {
  216. test::TaskEnvironment task_environment;
  217. auto task_runner = ThreadPool::CreateSequencedTaskRunner({});
  218. task_runner->PostTask(
  219. FROM_HERE, BindLambdaForTesting([&]() {
  220. thread_local_owner.Set(std::make_unique<SequenceCheckerOwner>());
  221. }));
  222. task_runner = nullptr;
  223. task_environment.RunUntilIdle();
  224. }
  225. }
  226. } // namespace base