Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(66)

Side by Side Diff: base/threading/thread_checker_unittest.cc

Issue 2213263002: Make ThreadChecker::CalledOnValidThread() return true when called from the same task. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: CR gab #6 (fix comment) Created 4 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include <memory> 5 #include <memory>
6 6
7 #include "base/bind.h" 7 #include "base/bind.h"
8 #include "base/bind_helpers.h" 8 #include "base/bind_helpers.h"
9 #include "base/macros.h" 9 #include "base/macros.h"
10 #include "base/memory/ref_counted.h" 10 #include "base/memory/ref_counted.h"
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after
62 SequenceToken sequence_token) { 62 SequenceToken sequence_token) {
63 ThreadTaskRunnerHandle thread_task_runner_handle( 63 ThreadTaskRunnerHandle thread_task_runner_handle(
64 make_scoped_refptr(new TestSimpleTaskRunner)); 64 make_scoped_refptr(new TestSimpleTaskRunner));
65 ScopedSetSequenceTokenForCurrentThread 65 ScopedSetSequenceTokenForCurrentThread
66 scoped_set_sequence_token_for_current_thread(sequence_token); 66 scoped_set_sequence_token_for_current_thread(sequence_token);
67 ExpectNotCalledOnValidThread(thread_checker); 67 ExpectNotCalledOnValidThread(thread_checker);
68 } 68 }
69 69
70 } // namespace 70 } // namespace
71 71
72 TEST(ThreadCheckerTest, CallsAllowedSameThreadNoSequenceToken) { 72 TEST(ThreadCheckerTest, AllowedSameThreadNoSequenceToken) {
73 ThreadCheckerImpl thread_checker; 73 ThreadCheckerImpl thread_checker;
74 EXPECT_TRUE(thread_checker.CalledOnValidThread()); 74 EXPECT_TRUE(thread_checker.CalledOnValidThread());
75 } 75 }
76 76
77 TEST(ThreadCheckerTest, 77 TEST(ThreadCheckerTest,
78 CallsAllowedSameThreadSameSequenceTokenWithThreadTaskRunnerHandle) { 78 AllowedSameThreadAndSequenceDifferentTasksWithThreadTaskRunnerHandle) {
79 ThreadTaskRunnerHandle thread_task_runner_handle( 79 ThreadTaskRunnerHandle thread_task_runner_handle(
80 make_scoped_refptr(new TestSimpleTaskRunner)); 80 make_scoped_refptr(new TestSimpleTaskRunner));
81
82 std::unique_ptr<ThreadCheckerImpl> thread_checker;
83 const SequenceToken sequence_token = SequenceToken::Create();
84
85 {
86 ScopedSetSequenceTokenForCurrentThread
87 scoped_set_sequence_token_for_current_thread(sequence_token);
88 thread_checker.reset(new ThreadCheckerImpl);
89 }
90
91 {
92 ScopedSetSequenceTokenForCurrentThread
93 scoped_set_sequence_token_for_current_thread(sequence_token);
94 EXPECT_TRUE(thread_checker->CalledOnValidThread());
95 }
96 }
97
98 TEST(ThreadCheckerTest,
99 AllowedSameThreadSequenceAndTaskNoThreadTaskRunnerHandle) {
81 ScopedSetSequenceTokenForCurrentThread 100 ScopedSetSequenceTokenForCurrentThread
82 scoped_set_sequence_token_for_current_thread(SequenceToken::Create()); 101 scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
83 ThreadCheckerImpl thread_checker; 102 ThreadCheckerImpl thread_checker;
84 EXPECT_TRUE(thread_checker.CalledOnValidThread()); 103 EXPECT_TRUE(thread_checker.CalledOnValidThread());
85 } 104 }
86 105
87 TEST(ThreadCheckerTest, 106 TEST(ThreadCheckerTest,
88 CallsDisallowedSameThreadSameSequenceTokenNoThreadTaskRunnerHandle) { 107 DisallowedSameThreadAndSequenceDifferentTasksNoThreadTaskRunnerHandle) {
89 ScopedSetSequenceTokenForCurrentThread 108 std::unique_ptr<ThreadCheckerImpl> thread_checker;
90 scoped_set_sequence_token_for_current_thread(SequenceToken::Create()); 109
91 ThreadCheckerImpl thread_checker; 110 {
92 EXPECT_FALSE(thread_checker.CalledOnValidThread()); 111 ScopedSetSequenceTokenForCurrentThread
112 scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
113 thread_checker.reset(new ThreadCheckerImpl);
114 }
115
116 {
117 ScopedSetSequenceTokenForCurrentThread
118 scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
119 EXPECT_FALSE(thread_checker->CalledOnValidThread());
120 }
93 } 121 }
94 122
95 TEST(ThreadCheckerTest, CallsDisallowedOnDifferentThreadsNoSequenceToken) { 123 TEST(ThreadCheckerTest, DisallowedDifferentThreadsNoSequenceToken) {
96 ThreadCheckerImpl thread_checker; 124 ThreadCheckerImpl thread_checker;
97 RunCallbackOnNewThreadSynchronously( 125 RunCallbackOnNewThreadSynchronously(
98 Bind(&ExpectNotCalledOnValidThread, Unretained(&thread_checker))); 126 Bind(&ExpectNotCalledOnValidThread, Unretained(&thread_checker)));
99 } 127 }
100 128
101 TEST(ThreadCheckerTest, CallsDisallowedOnDifferentThreadsSameSequenceToken) { 129 TEST(ThreadCheckerTest, DisallowedDifferentThreadsSameSequence) {
102 ThreadTaskRunnerHandle thread_task_runner_handle( 130 ThreadTaskRunnerHandle thread_task_runner_handle(
103 make_scoped_refptr(new TestSimpleTaskRunner)); 131 make_scoped_refptr(new TestSimpleTaskRunner));
104 const SequenceToken sequence_token(SequenceToken::Create()); 132 const SequenceToken sequence_token(SequenceToken::Create());
105 133
106 ScopedSetSequenceTokenForCurrentThread 134 ScopedSetSequenceTokenForCurrentThread
107 scoped_set_sequence_token_for_current_thread(sequence_token); 135 scoped_set_sequence_token_for_current_thread(sequence_token);
108 ThreadCheckerImpl thread_checker; 136 ThreadCheckerImpl thread_checker;
109 EXPECT_TRUE(thread_checker.CalledOnValidThread()); 137 EXPECT_TRUE(thread_checker.CalledOnValidThread());
110 138
111 RunCallbackOnNewThreadSynchronously(Bind( 139 RunCallbackOnNewThreadSynchronously(Bind(
112 &ExpectNotCalledOnValidThreadWithSequenceTokenAndThreadTaskRunnerHandle, 140 &ExpectNotCalledOnValidThreadWithSequenceTokenAndThreadTaskRunnerHandle,
113 Unretained(&thread_checker), sequence_token)); 141 Unretained(&thread_checker), sequence_token));
114 } 142 }
115 143
116 TEST(ThreadCheckerTest, CallsDisallowedSameThreadDifferentSequenceToken) { 144 TEST(ThreadCheckerTest, DisallowedSameThreadDifferentSequence) {
117 std::unique_ptr<ThreadCheckerImpl> thread_checker; 145 std::unique_ptr<ThreadCheckerImpl> thread_checker;
118 146
119 ThreadTaskRunnerHandle thread_task_runner_handle( 147 ThreadTaskRunnerHandle thread_task_runner_handle(
120 make_scoped_refptr(new TestSimpleTaskRunner)); 148 make_scoped_refptr(new TestSimpleTaskRunner));
121 149
122 { 150 {
123 ScopedSetSequenceTokenForCurrentThread 151 ScopedSetSequenceTokenForCurrentThread
124 scoped_set_sequence_token_for_current_thread(SequenceToken::Create()); 152 scoped_set_sequence_token_for_current_thread(SequenceToken::Create());
125 thread_checker.reset(new ThreadCheckerImpl); 153 thread_checker.reset(new ThreadCheckerImpl);
126 } 154 }
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
158 186
159 // Verify that CalledOnValidThread() returns true when called on a different 187 // Verify that CalledOnValidThread() returns true when called on a different
160 // thread after a call to DetachFromThread(). 188 // thread after a call to DetachFromThread().
161 RunCallbackOnNewThreadSynchronously( 189 RunCallbackOnNewThreadSynchronously(
162 Bind(&ExpectCalledOnValidThread, Unretained(&thread_checker))); 190 Bind(&ExpectCalledOnValidThread, Unretained(&thread_checker)));
163 191
164 EXPECT_FALSE(thread_checker.CalledOnValidThread()); 192 EXPECT_FALSE(thread_checker.CalledOnValidThread());
165 } 193 }
166 194
167 } // namespace base 195 } // namespace base
OLDNEW
« base/sequence_token.cc ('K') | « base/threading/thread_checker_impl.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698