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 "base/bind.h" | 5 #include "base/bind.h" |
6 #include "base/compiler_specific.h" | 6 #include "base/compiler_specific.h" |
7 #include "base/message_loop/message_loop.h" | 7 #include "base/message_loop/message_loop.h" |
8 #include "base/threading/thread.h" | 8 #include "base/threading/thread.h" |
9 #include "jingle/glue/thread_wrapper.h" | 9 #include "jingle/glue/thread_wrapper.h" |
10 #include "testing/gmock/include/gmock/gmock.h" | 10 #include "testing/gmock/include/gmock/gmock.h" |
(...skipping 10 matching lines...) Expand all Loading... |
21 static const uint32 kTestMessage2 = 2; | 21 static const uint32 kTestMessage2 = 2; |
22 | 22 |
23 static const int kTestDelayMs1 = 10; | 23 static const int kTestDelayMs1 = 10; |
24 static const int kTestDelayMs2 = 20; | 24 static const int kTestDelayMs2 = 20; |
25 static const int kTestDelayMs3 = 30; | 25 static const int kTestDelayMs3 = 30; |
26 static const int kTestDelayMs4 = 40; | 26 static const int kTestDelayMs4 = 40; |
27 static const int kMaxTestDelay = 40; | 27 static const int kMaxTestDelay = 40; |
28 | 28 |
29 namespace { | 29 namespace { |
30 | 30 |
31 class MockMessageHandler : public rtc::MessageHandler { | 31 class MockMessageHandler : public talk_base::MessageHandler { |
32 public: | 32 public: |
33 MOCK_METHOD1(OnMessage, void(rtc::Message* msg)); | 33 MOCK_METHOD1(OnMessage, void(talk_base::Message* msg)); |
34 }; | 34 }; |
35 | 35 |
36 MATCHER_P3(MatchMessage, handler, message_id, data, "") { | 36 MATCHER_P3(MatchMessage, handler, message_id, data, "") { |
37 return arg->phandler == handler && | 37 return arg->phandler == handler && |
38 arg->message_id == message_id && | 38 arg->message_id == message_id && |
39 arg->pdata == data; | 39 arg->pdata == data; |
40 } | 40 } |
41 | 41 |
42 ACTION(DeleteMessageData) { | 42 ACTION(DeleteMessageData) { |
43 delete arg0->pdata; | 43 delete arg0->pdata; |
(...skipping 15 matching lines...) Expand all Loading... |
59 bool* deleted_; | 59 bool* deleted_; |
60 }; | 60 }; |
61 | 61 |
62 } // namespace | 62 } // namespace |
63 | 63 |
64 class ThreadWrapperTest : public testing::Test { | 64 class ThreadWrapperTest : public testing::Test { |
65 public: | 65 public: |
66 // This method is used by the SendDuringSend test. It sends message to the | 66 // This method is used by the SendDuringSend test. It sends message to the |
67 // main thread synchronously using Send(). | 67 // main thread synchronously using Send(). |
68 void PingMainThread() { | 68 void PingMainThread() { |
69 rtc::MessageData* data = new rtc::MessageData(); | 69 talk_base::MessageData* data = new talk_base::MessageData(); |
70 MockMessageHandler handler; | 70 MockMessageHandler handler; |
71 | 71 |
72 EXPECT_CALL(handler, OnMessage( | 72 EXPECT_CALL(handler, OnMessage( |
73 MatchMessage(&handler, kTestMessage2, data))) | 73 MatchMessage(&handler, kTestMessage2, data))) |
74 .WillOnce(DeleteMessageData()); | 74 .WillOnce(DeleteMessageData()); |
75 thread_->Send(&handler, kTestMessage2, data); | 75 thread_->Send(&handler, kTestMessage2, data); |
76 } | 76 } |
77 | 77 |
78 protected: | 78 protected: |
79 ThreadWrapperTest() | 79 ThreadWrapperTest() |
80 : thread_(NULL) { | 80 : thread_(NULL) { |
81 } | 81 } |
82 | 82 |
83 virtual void SetUp() OVERRIDE { | 83 virtual void SetUp() OVERRIDE { |
84 JingleThreadWrapper::EnsureForCurrentMessageLoop(); | 84 JingleThreadWrapper::EnsureForCurrentMessageLoop(); |
85 thread_ = rtc::Thread::Current(); | 85 thread_ = talk_base::Thread::Current(); |
86 } | 86 } |
87 | 87 |
88 // ThreadWrapper destroyes itself when |message_loop_| is destroyed. | 88 // ThreadWrapper destroyes itself when |message_loop_| is destroyed. |
89 base::MessageLoop message_loop_; | 89 base::MessageLoop message_loop_; |
90 rtc::Thread* thread_; | 90 talk_base::Thread* thread_; |
91 MockMessageHandler handler1_; | 91 MockMessageHandler handler1_; |
92 MockMessageHandler handler2_; | 92 MockMessageHandler handler2_; |
93 }; | 93 }; |
94 | 94 |
95 TEST_F(ThreadWrapperTest, Post) { | 95 TEST_F(ThreadWrapperTest, Post) { |
96 rtc::MessageData* data1 = new rtc::MessageData(); | 96 talk_base::MessageData* data1 = new talk_base::MessageData(); |
97 rtc::MessageData* data2 = new rtc::MessageData(); | 97 talk_base::MessageData* data2 = new talk_base::MessageData(); |
98 rtc::MessageData* data3 = new rtc::MessageData(); | 98 talk_base::MessageData* data3 = new talk_base::MessageData(); |
99 rtc::MessageData* data4 = new rtc::MessageData(); | 99 talk_base::MessageData* data4 = new talk_base::MessageData(); |
100 | 100 |
101 thread_->Post(&handler1_, kTestMessage1, data1); | 101 thread_->Post(&handler1_, kTestMessage1, data1); |
102 thread_->Post(&handler1_, kTestMessage2, data2); | 102 thread_->Post(&handler1_, kTestMessage2, data2); |
103 thread_->Post(&handler2_, kTestMessage1, data3); | 103 thread_->Post(&handler2_, kTestMessage1, data3); |
104 thread_->Post(&handler2_, kTestMessage1, data4); | 104 thread_->Post(&handler2_, kTestMessage1, data4); |
105 | 105 |
106 InSequence in_seq; | 106 InSequence in_seq; |
107 | 107 |
108 EXPECT_CALL(handler1_, OnMessage( | 108 EXPECT_CALL(handler1_, OnMessage( |
109 MatchMessage(&handler1_, kTestMessage1, data1))) | 109 MatchMessage(&handler1_, kTestMessage1, data1))) |
110 .WillOnce(DeleteMessageData()); | 110 .WillOnce(DeleteMessageData()); |
111 EXPECT_CALL(handler1_, OnMessage( | 111 EXPECT_CALL(handler1_, OnMessage( |
112 MatchMessage(&handler1_, kTestMessage2, data2))) | 112 MatchMessage(&handler1_, kTestMessage2, data2))) |
113 .WillOnce(DeleteMessageData()); | 113 .WillOnce(DeleteMessageData()); |
114 EXPECT_CALL(handler2_, OnMessage( | 114 EXPECT_CALL(handler2_, OnMessage( |
115 MatchMessage(&handler2_, kTestMessage1, data3))) | 115 MatchMessage(&handler2_, kTestMessage1, data3))) |
116 .WillOnce(DeleteMessageData()); | 116 .WillOnce(DeleteMessageData()); |
117 EXPECT_CALL(handler2_, OnMessage( | 117 EXPECT_CALL(handler2_, OnMessage( |
118 MatchMessage(&handler2_, kTestMessage1, data4))) | 118 MatchMessage(&handler2_, kTestMessage1, data4))) |
119 .WillOnce(DeleteMessageData()); | 119 .WillOnce(DeleteMessageData()); |
120 | 120 |
121 message_loop_.RunUntilIdle(); | 121 message_loop_.RunUntilIdle(); |
122 } | 122 } |
123 | 123 |
124 TEST_F(ThreadWrapperTest, PostDelayed) { | 124 TEST_F(ThreadWrapperTest, PostDelayed) { |
125 rtc::MessageData* data1 = new rtc::MessageData(); | 125 talk_base::MessageData* data1 = new talk_base::MessageData(); |
126 rtc::MessageData* data2 = new rtc::MessageData(); | 126 talk_base::MessageData* data2 = new talk_base::MessageData(); |
127 rtc::MessageData* data3 = new rtc::MessageData(); | 127 talk_base::MessageData* data3 = new talk_base::MessageData(); |
128 rtc::MessageData* data4 = new rtc::MessageData(); | 128 talk_base::MessageData* data4 = new talk_base::MessageData(); |
129 | 129 |
130 thread_->PostDelayed(kTestDelayMs1, &handler1_, kTestMessage1, data1); | 130 thread_->PostDelayed(kTestDelayMs1, &handler1_, kTestMessage1, data1); |
131 thread_->PostDelayed(kTestDelayMs2, &handler1_, kTestMessage2, data2); | 131 thread_->PostDelayed(kTestDelayMs2, &handler1_, kTestMessage2, data2); |
132 thread_->PostDelayed(kTestDelayMs3, &handler2_, kTestMessage1, data3); | 132 thread_->PostDelayed(kTestDelayMs3, &handler2_, kTestMessage1, data3); |
133 thread_->PostDelayed(kTestDelayMs4, &handler2_, kTestMessage1, data4); | 133 thread_->PostDelayed(kTestDelayMs4, &handler2_, kTestMessage1, data4); |
134 | 134 |
135 InSequence in_seq; | 135 InSequence in_seq; |
136 | 136 |
137 EXPECT_CALL(handler1_, OnMessage( | 137 EXPECT_CALL(handler1_, OnMessage( |
138 MatchMessage(&handler1_, kTestMessage1, data1))) | 138 MatchMessage(&handler1_, kTestMessage1, data1))) |
(...skipping 18 matching lines...) Expand all Loading... |
157 TEST_F(ThreadWrapperTest, Clear) { | 157 TEST_F(ThreadWrapperTest, Clear) { |
158 thread_->Post(&handler1_, kTestMessage1, NULL); | 158 thread_->Post(&handler1_, kTestMessage1, NULL); |
159 thread_->Post(&handler1_, kTestMessage2, NULL); | 159 thread_->Post(&handler1_, kTestMessage2, NULL); |
160 thread_->Post(&handler2_, kTestMessage1, NULL); | 160 thread_->Post(&handler2_, kTestMessage1, NULL); |
161 thread_->Post(&handler2_, kTestMessage2, NULL); | 161 thread_->Post(&handler2_, kTestMessage2, NULL); |
162 | 162 |
163 thread_->Clear(&handler1_, kTestMessage2); | 163 thread_->Clear(&handler1_, kTestMessage2); |
164 | 164 |
165 InSequence in_seq; | 165 InSequence in_seq; |
166 | 166 |
167 rtc::MessageData* null_data = NULL; | 167 talk_base::MessageData* null_data = NULL; |
168 EXPECT_CALL(handler1_, OnMessage( | 168 EXPECT_CALL(handler1_, OnMessage( |
169 MatchMessage(&handler1_, kTestMessage1, null_data))) | 169 MatchMessage(&handler1_, kTestMessage1, null_data))) |
170 .WillOnce(DeleteMessageData()); | 170 .WillOnce(DeleteMessageData()); |
171 EXPECT_CALL(handler2_, OnMessage( | 171 EXPECT_CALL(handler2_, OnMessage( |
172 MatchMessage(&handler2_, kTestMessage1, null_data))) | 172 MatchMessage(&handler2_, kTestMessage1, null_data))) |
173 .WillOnce(DeleteMessageData()); | 173 .WillOnce(DeleteMessageData()); |
174 EXPECT_CALL(handler2_, OnMessage( | 174 EXPECT_CALL(handler2_, OnMessage( |
175 MatchMessage(&handler2_, kTestMessage2, null_data))) | 175 MatchMessage(&handler2_, kTestMessage2, null_data))) |
176 .WillOnce(DeleteMessageData()); | 176 .WillOnce(DeleteMessageData()); |
177 | 177 |
178 message_loop_.RunUntilIdle(); | 178 message_loop_.RunUntilIdle(); |
179 } | 179 } |
180 | 180 |
181 TEST_F(ThreadWrapperTest, ClearDelayed) { | 181 TEST_F(ThreadWrapperTest, ClearDelayed) { |
182 thread_->PostDelayed(kTestDelayMs1, &handler1_, kTestMessage1, NULL); | 182 thread_->PostDelayed(kTestDelayMs1, &handler1_, kTestMessage1, NULL); |
183 thread_->PostDelayed(kTestDelayMs2, &handler1_, kTestMessage2, NULL); | 183 thread_->PostDelayed(kTestDelayMs2, &handler1_, kTestMessage2, NULL); |
184 thread_->PostDelayed(kTestDelayMs3, &handler2_, kTestMessage1, NULL); | 184 thread_->PostDelayed(kTestDelayMs3, &handler2_, kTestMessage1, NULL); |
185 thread_->PostDelayed(kTestDelayMs4, &handler2_, kTestMessage1, NULL); | 185 thread_->PostDelayed(kTestDelayMs4, &handler2_, kTestMessage1, NULL); |
186 | 186 |
187 thread_->Clear(&handler1_, kTestMessage2); | 187 thread_->Clear(&handler1_, kTestMessage2); |
188 | 188 |
189 InSequence in_seq; | 189 InSequence in_seq; |
190 | 190 |
191 rtc::MessageData* null_data = NULL; | 191 talk_base::MessageData* null_data = NULL; |
192 EXPECT_CALL(handler1_, OnMessage( | 192 EXPECT_CALL(handler1_, OnMessage( |
193 MatchMessage(&handler1_, kTestMessage1, null_data))) | 193 MatchMessage(&handler1_, kTestMessage1, null_data))) |
194 .WillOnce(DeleteMessageData()); | 194 .WillOnce(DeleteMessageData()); |
195 EXPECT_CALL(handler2_, OnMessage( | 195 EXPECT_CALL(handler2_, OnMessage( |
196 MatchMessage(&handler2_, kTestMessage1, null_data))) | 196 MatchMessage(&handler2_, kTestMessage1, null_data))) |
197 .WillOnce(DeleteMessageData()); | 197 .WillOnce(DeleteMessageData()); |
198 EXPECT_CALL(handler2_, OnMessage( | 198 EXPECT_CALL(handler2_, OnMessage( |
199 MatchMessage(&handler2_, kTestMessage1, null_data))) | 199 MatchMessage(&handler2_, kTestMessage1, null_data))) |
200 .WillOnce(DeleteMessageData()); | 200 .WillOnce(DeleteMessageData()); |
201 | 201 |
202 message_loop_.PostDelayedTask( | 202 message_loop_.PostDelayedTask( |
203 FROM_HERE, | 203 FROM_HERE, |
204 base::MessageLoop::QuitClosure(), | 204 base::MessageLoop::QuitClosure(), |
205 base::TimeDelta::FromMilliseconds(kMaxTestDelay)); | 205 base::TimeDelta::FromMilliseconds(kMaxTestDelay)); |
206 message_loop_.Run(); | 206 message_loop_.Run(); |
207 } | 207 } |
208 | 208 |
209 // Verify that the queue is cleared when a handler is destroyed. | 209 // Verify that the queue is cleared when a handler is destroyed. |
210 TEST_F(ThreadWrapperTest, ClearDestoroyed) { | 210 TEST_F(ThreadWrapperTest, ClearDestoroyed) { |
211 MockMessageHandler* handler_ptr; | 211 MockMessageHandler* handler_ptr; |
212 { | 212 { |
213 MockMessageHandler handler; | 213 MockMessageHandler handler; |
214 handler_ptr = &handler; | 214 handler_ptr = &handler; |
215 thread_->Post(&handler, kTestMessage1, NULL); | 215 thread_->Post(&handler, kTestMessage1, NULL); |
216 } | 216 } |
217 rtc::MessageList removed; | 217 talk_base::MessageList removed; |
218 thread_->Clear(handler_ptr, rtc::MQID_ANY, &removed); | 218 thread_->Clear(handler_ptr, talk_base::MQID_ANY, &removed); |
219 DCHECK_EQ(0U, removed.size()); | 219 DCHECK_EQ(0U, removed.size()); |
220 } | 220 } |
221 | 221 |
222 // Verify that Send() calls handler synchronously when called on the | 222 // Verify that Send() calls handler synchronously when called on the |
223 // same thread. | 223 // same thread. |
224 TEST_F(ThreadWrapperTest, SendSameThread) { | 224 TEST_F(ThreadWrapperTest, SendSameThread) { |
225 rtc::MessageData* data = new rtc::MessageData(); | 225 talk_base::MessageData* data = new talk_base::MessageData(); |
226 | 226 |
227 EXPECT_CALL(handler1_, OnMessage( | 227 EXPECT_CALL(handler1_, OnMessage( |
228 MatchMessage(&handler1_, kTestMessage1, data))) | 228 MatchMessage(&handler1_, kTestMessage1, data))) |
229 .WillOnce(DeleteMessageData()); | 229 .WillOnce(DeleteMessageData()); |
230 thread_->Send(&handler1_, kTestMessage1, data); | 230 thread_->Send(&handler1_, kTestMessage1, data); |
231 } | 231 } |
232 | 232 |
233 void InitializeWrapperForNewThread(rtc::Thread** thread, | 233 void InitializeWrapperForNewThread(talk_base::Thread** thread, |
234 base::WaitableEvent* done_event) { | 234 base::WaitableEvent* done_event) { |
235 JingleThreadWrapper::EnsureForCurrentMessageLoop(); | 235 JingleThreadWrapper::EnsureForCurrentMessageLoop(); |
236 JingleThreadWrapper::current()->set_send_allowed(true); | 236 JingleThreadWrapper::current()->set_send_allowed(true); |
237 *thread = JingleThreadWrapper::current(); | 237 *thread = JingleThreadWrapper::current(); |
238 done_event->Signal(); | 238 done_event->Signal(); |
239 } | 239 } |
240 | 240 |
241 // Verify that Send() calls handler synchronously when called for a | 241 // Verify that Send() calls handler synchronously when called for a |
242 // different thread. | 242 // different thread. |
243 TEST_F(ThreadWrapperTest, SendToOtherThread) { | 243 TEST_F(ThreadWrapperTest, SendToOtherThread) { |
244 JingleThreadWrapper::current()->set_send_allowed(true); | 244 JingleThreadWrapper::current()->set_send_allowed(true); |
245 | 245 |
246 base::Thread second_thread("JingleThreadWrapperTest"); | 246 base::Thread second_thread("JingleThreadWrapperTest"); |
247 second_thread.Start(); | 247 second_thread.Start(); |
248 | 248 |
249 base::WaitableEvent initialized_event(true, false); | 249 base::WaitableEvent initialized_event(true, false); |
250 rtc::Thread* target; | 250 talk_base::Thread* target; |
251 second_thread.message_loop()->PostTask( | 251 second_thread.message_loop()->PostTask( |
252 FROM_HERE, base::Bind(&InitializeWrapperForNewThread, | 252 FROM_HERE, base::Bind(&InitializeWrapperForNewThread, |
253 &target, &initialized_event)); | 253 &target, &initialized_event)); |
254 initialized_event.Wait(); | 254 initialized_event.Wait(); |
255 | 255 |
256 ASSERT_TRUE(target != NULL); | 256 ASSERT_TRUE(target != NULL); |
257 | 257 |
258 rtc::MessageData* data = new rtc::MessageData(); | 258 talk_base::MessageData* data = new talk_base::MessageData(); |
259 | 259 |
260 EXPECT_CALL(handler1_, OnMessage( | 260 EXPECT_CALL(handler1_, OnMessage( |
261 MatchMessage(&handler1_, kTestMessage1, data))) | 261 MatchMessage(&handler1_, kTestMessage1, data))) |
262 .WillOnce(DeleteMessageData()); | 262 .WillOnce(DeleteMessageData()); |
263 target->Send(&handler1_, kTestMessage1, data); | 263 target->Send(&handler1_, kTestMessage1, data); |
264 | 264 |
265 Mock::VerifyAndClearExpectations(&handler1_); | 265 Mock::VerifyAndClearExpectations(&handler1_); |
266 } | 266 } |
267 | 267 |
268 // Verify that thread handles Send() while another Send() is | 268 // Verify that thread handles Send() while another Send() is |
269 // pending. The test creates second thread and Send()s kTestMessage1 | 269 // pending. The test creates second thread and Send()s kTestMessage1 |
270 // to that thread. kTestMessage1 handler calls PingMainThread() which | 270 // to that thread. kTestMessage1 handler calls PingMainThread() which |
271 // tries to Send() kTestMessage2 to the main thread. | 271 // tries to Send() kTestMessage2 to the main thread. |
272 TEST_F(ThreadWrapperTest, SendDuringSend) { | 272 TEST_F(ThreadWrapperTest, SendDuringSend) { |
273 JingleThreadWrapper::current()->set_send_allowed(true); | 273 JingleThreadWrapper::current()->set_send_allowed(true); |
274 | 274 |
275 base::Thread second_thread("JingleThreadWrapperTest"); | 275 base::Thread second_thread("JingleThreadWrapperTest"); |
276 second_thread.Start(); | 276 second_thread.Start(); |
277 | 277 |
278 base::WaitableEvent initialized_event(true, false); | 278 base::WaitableEvent initialized_event(true, false); |
279 rtc::Thread* target; | 279 talk_base::Thread* target; |
280 second_thread.message_loop()->PostTask( | 280 second_thread.message_loop()->PostTask( |
281 FROM_HERE, base::Bind(&InitializeWrapperForNewThread, | 281 FROM_HERE, base::Bind(&InitializeWrapperForNewThread, |
282 &target, &initialized_event)); | 282 &target, &initialized_event)); |
283 initialized_event.Wait(); | 283 initialized_event.Wait(); |
284 | 284 |
285 ASSERT_TRUE(target != NULL); | 285 ASSERT_TRUE(target != NULL); |
286 | 286 |
287 rtc::MessageData* data = new rtc::MessageData(); | 287 talk_base::MessageData* data = new talk_base::MessageData(); |
288 | 288 |
289 EXPECT_CALL(handler1_, OnMessage( | 289 EXPECT_CALL(handler1_, OnMessage( |
290 MatchMessage(&handler1_, kTestMessage1, data))) | 290 MatchMessage(&handler1_, kTestMessage1, data))) |
291 .WillOnce(DoAll( | 291 .WillOnce(DoAll( |
292 InvokeWithoutArgs( | 292 InvokeWithoutArgs( |
293 this, &ThreadWrapperTest::PingMainThread), | 293 this, &ThreadWrapperTest::PingMainThread), |
294 DeleteMessageData())); | 294 DeleteMessageData())); |
295 target->Send(&handler1_, kTestMessage1, data); | 295 target->Send(&handler1_, kTestMessage1, data); |
296 | 296 |
297 Mock::VerifyAndClearExpectations(&handler1_); | 297 Mock::VerifyAndClearExpectations(&handler1_); |
298 } | 298 } |
299 | 299 |
300 TEST_F(ThreadWrapperTest, Dispose) { | 300 TEST_F(ThreadWrapperTest, Dispose) { |
301 bool deleted_ = false; | 301 bool deleted_ = false; |
302 thread_->Dispose(new DeletableObject(&deleted_)); | 302 thread_->Dispose(new DeletableObject(&deleted_)); |
303 EXPECT_FALSE(deleted_); | 303 EXPECT_FALSE(deleted_); |
304 message_loop_.RunUntilIdle(); | 304 message_loop_.RunUntilIdle(); |
305 EXPECT_TRUE(deleted_); | 305 EXPECT_TRUE(deleted_); |
306 } | 306 } |
307 | 307 |
308 } // namespace jingle_glue | 308 } // namespace jingle_glue |
OLD | NEW |