OLD | NEW |
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 Loading... |
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 Loading... |
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 |
OLD | NEW |