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 "jingle/glue/thread_wrapper.h" | 5 #include "jingle/glue/thread_wrapper.h" |
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/lazy_instance.h" | 9 #include "base/lazy_instance.h" |
10 #include "base/threading/thread_local.h" | 10 #include "base/threading/thread_local.h" |
11 #include "third_party/webrtc/base/nullsocketserver.h" | 11 #include "third_party/libjingle/source/talk/base/nullsocketserver.h" |
12 | 12 |
13 namespace jingle_glue { | 13 namespace jingle_glue { |
14 | 14 |
15 struct JingleThreadWrapper::PendingSend { | 15 struct JingleThreadWrapper::PendingSend { |
16 PendingSend(const rtc::Message& message_value) | 16 PendingSend(const talk_base::Message& message_value) |
17 : sending_thread(JingleThreadWrapper::current()), | 17 : sending_thread(JingleThreadWrapper::current()), |
18 message(message_value), | 18 message(message_value), |
19 done_event(true, false) { | 19 done_event(true, false) { |
20 DCHECK(sending_thread); | 20 DCHECK(sending_thread); |
21 } | 21 } |
22 | 22 |
23 JingleThreadWrapper* sending_thread; | 23 JingleThreadWrapper* sending_thread; |
24 rtc::Message message; | 24 talk_base::Message message; |
25 base::WaitableEvent done_event; | 25 base::WaitableEvent done_event; |
26 }; | 26 }; |
27 | 27 |
28 base::LazyInstance<base::ThreadLocalPointer<JingleThreadWrapper> > | 28 base::LazyInstance<base::ThreadLocalPointer<JingleThreadWrapper> > |
29 g_jingle_thread_wrapper = LAZY_INSTANCE_INITIALIZER; | 29 g_jingle_thread_wrapper = LAZY_INSTANCE_INITIALIZER; |
30 | 30 |
31 // static | 31 // static |
32 void JingleThreadWrapper::EnsureForCurrentMessageLoop() { | 32 void JingleThreadWrapper::EnsureForCurrentMessageLoop() { |
33 if (JingleThreadWrapper::current() == NULL) { | 33 if (JingleThreadWrapper::current() == NULL) { |
34 base::MessageLoop* message_loop = base::MessageLoop::current(); | 34 base::MessageLoop* message_loop = base::MessageLoop::current(); |
35 g_jingle_thread_wrapper.Get() | 35 g_jingle_thread_wrapper.Get() |
36 .Set(new JingleThreadWrapper(message_loop->message_loop_proxy())); | 36 .Set(new JingleThreadWrapper(message_loop->message_loop_proxy())); |
37 message_loop->AddDestructionObserver(current()); | 37 message_loop->AddDestructionObserver(current()); |
38 } | 38 } |
39 | 39 |
40 DCHECK_EQ(rtc::Thread::Current(), current()); | 40 DCHECK_EQ(talk_base::Thread::Current(), current()); |
41 } | 41 } |
42 | 42 |
43 // static | 43 // static |
44 JingleThreadWrapper* JingleThreadWrapper::current() { | 44 JingleThreadWrapper* JingleThreadWrapper::current() { |
45 return g_jingle_thread_wrapper.Get().Get(); | 45 return g_jingle_thread_wrapper.Get().Get(); |
46 } | 46 } |
47 | 47 |
48 JingleThreadWrapper::JingleThreadWrapper( | 48 JingleThreadWrapper::JingleThreadWrapper( |
49 scoped_refptr<base::SingleThreadTaskRunner> task_runner) | 49 scoped_refptr<base::SingleThreadTaskRunner> task_runner) |
50 : rtc::Thread(new rtc::NullSocketServer()), | 50 : talk_base::Thread(new talk_base::NullSocketServer()), |
51 task_runner_(task_runner), | 51 task_runner_(task_runner), |
52 send_allowed_(false), | 52 send_allowed_(false), |
53 last_task_id_(0), | 53 last_task_id_(0), |
54 pending_send_event_(true, false), | 54 pending_send_event_(true, false), |
55 weak_ptr_factory_(this) { | 55 weak_ptr_factory_(this) { |
56 DCHECK(task_runner->BelongsToCurrentThread()); | 56 DCHECK(task_runner->BelongsToCurrentThread()); |
57 DCHECK(!rtc::Thread::Current()); | 57 DCHECK(!talk_base::Thread::Current()); |
58 weak_ptr_ = weak_ptr_factory_.GetWeakPtr(); | 58 weak_ptr_ = weak_ptr_factory_.GetWeakPtr(); |
59 rtc::MessageQueueManager::Add(this); | 59 talk_base::MessageQueueManager::Add(this); |
60 WrapCurrent(); | 60 WrapCurrent(); |
61 } | 61 } |
62 | 62 |
63 JingleThreadWrapper::~JingleThreadWrapper() { | 63 JingleThreadWrapper::~JingleThreadWrapper() { |
64 Clear(NULL, rtc::MQID_ANY, NULL); | 64 Clear(NULL, talk_base::MQID_ANY, NULL); |
65 } | 65 } |
66 | 66 |
67 void JingleThreadWrapper::WillDestroyCurrentMessageLoop() { | 67 void JingleThreadWrapper::WillDestroyCurrentMessageLoop() { |
68 DCHECK_EQ(rtc::Thread::Current(), current()); | 68 DCHECK_EQ(talk_base::Thread::Current(), current()); |
69 UnwrapCurrent(); | 69 UnwrapCurrent(); |
70 g_jingle_thread_wrapper.Get().Set(NULL); | 70 g_jingle_thread_wrapper.Get().Set(NULL); |
71 rtc::ThreadManager::Instance()->SetCurrentThread(NULL); | 71 talk_base::ThreadManager::Instance()->SetCurrentThread(NULL); |
72 rtc::MessageQueueManager::Remove(this); | 72 talk_base::MessageQueueManager::Remove(this); |
73 rtc::SocketServer* ss = socketserver(); | 73 talk_base::SocketServer* ss = socketserver(); |
74 delete this; | 74 delete this; |
75 delete ss; | 75 delete ss; |
76 } | 76 } |
77 | 77 |
78 void JingleThreadWrapper::Post( | 78 void JingleThreadWrapper::Post( |
79 rtc::MessageHandler* handler, uint32 message_id, | 79 talk_base::MessageHandler* handler, uint32 message_id, |
80 rtc::MessageData* data, bool time_sensitive) { | 80 talk_base::MessageData* data, bool time_sensitive) { |
81 PostTaskInternal(0, handler, message_id, data); | 81 PostTaskInternal(0, handler, message_id, data); |
82 } | 82 } |
83 | 83 |
84 void JingleThreadWrapper::PostDelayed( | 84 void JingleThreadWrapper::PostDelayed( |
85 int delay_ms, rtc::MessageHandler* handler, | 85 int delay_ms, talk_base::MessageHandler* handler, |
86 uint32 message_id, rtc::MessageData* data) { | 86 uint32 message_id, talk_base::MessageData* data) { |
87 PostTaskInternal(delay_ms, handler, message_id, data); | 87 PostTaskInternal(delay_ms, handler, message_id, data); |
88 } | 88 } |
89 | 89 |
90 void JingleThreadWrapper::Clear(rtc::MessageHandler* handler, uint32 id, | 90 void JingleThreadWrapper::Clear(talk_base::MessageHandler* handler, uint32 id, |
91 rtc::MessageList* removed) { | 91 talk_base::MessageList* removed) { |
92 base::AutoLock auto_lock(lock_); | 92 base::AutoLock auto_lock(lock_); |
93 | 93 |
94 for (MessagesQueue::iterator it = messages_.begin(); | 94 for (MessagesQueue::iterator it = messages_.begin(); |
95 it != messages_.end();) { | 95 it != messages_.end();) { |
96 MessagesQueue::iterator next = it; | 96 MessagesQueue::iterator next = it; |
97 ++next; | 97 ++next; |
98 | 98 |
99 if (it->second.Match(handler, id)) { | 99 if (it->second.Match(handler, id)) { |
100 if (removed) { | 100 if (removed) { |
101 removed->push_back(it->second); | 101 removed->push_back(it->second); |
(...skipping 18 matching lines...) Expand all Loading... |
120 delete (*it)->message.pdata; | 120 delete (*it)->message.pdata; |
121 } | 121 } |
122 (*it)->done_event.Signal(); | 122 (*it)->done_event.Signal(); |
123 pending_send_messages_.erase(it); | 123 pending_send_messages_.erase(it); |
124 } | 124 } |
125 | 125 |
126 it = next; | 126 it = next; |
127 } | 127 } |
128 } | 128 } |
129 | 129 |
130 void JingleThreadWrapper::Send(rtc::MessageHandler *handler, uint32 id, | 130 void JingleThreadWrapper::Send(talk_base::MessageHandler *handler, uint32 id, |
131 rtc::MessageData *data) { | 131 talk_base::MessageData *data) { |
132 if (fStop_) | 132 if (fStop_) |
133 return; | 133 return; |
134 | 134 |
135 JingleThreadWrapper* current_thread = JingleThreadWrapper::current(); | 135 JingleThreadWrapper* current_thread = JingleThreadWrapper::current(); |
136 DCHECK(current_thread != NULL) << "Send() can be called only from a " | 136 DCHECK(current_thread != NULL) << "Send() can be called only from a " |
137 "thread that has JingleThreadWrapper."; | 137 "thread that has JingleThreadWrapper."; |
138 | 138 |
139 rtc::Message message; | 139 talk_base::Message message; |
140 message.phandler = handler; | 140 message.phandler = handler; |
141 message.message_id = id; | 141 message.message_id = id; |
142 message.pdata = data; | 142 message.pdata = data; |
143 | 143 |
144 if (current_thread == this) { | 144 if (current_thread == this) { |
145 handler->OnMessage(&message); | 145 handler->OnMessage(&message); |
146 return; | 146 return; |
147 } | 147 } |
148 | 148 |
149 // Send message from a thread different than |this|. | 149 // Send message from a thread different than |this|. |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
193 } | 193 } |
194 } | 194 } |
195 if (pending_send) { | 195 if (pending_send) { |
196 pending_send->message.phandler->OnMessage(&pending_send->message); | 196 pending_send->message.phandler->OnMessage(&pending_send->message); |
197 pending_send->done_event.Signal(); | 197 pending_send->done_event.Signal(); |
198 } | 198 } |
199 } | 199 } |
200 } | 200 } |
201 | 201 |
202 void JingleThreadWrapper::PostTaskInternal( | 202 void JingleThreadWrapper::PostTaskInternal( |
203 int delay_ms, rtc::MessageHandler* handler, | 203 int delay_ms, talk_base::MessageHandler* handler, |
204 uint32 message_id, rtc::MessageData* data) { | 204 uint32 message_id, talk_base::MessageData* data) { |
205 int task_id; | 205 int task_id; |
206 rtc::Message message; | 206 talk_base::Message message; |
207 message.phandler = handler; | 207 message.phandler = handler; |
208 message.message_id = message_id; | 208 message.message_id = message_id; |
209 message.pdata = data; | 209 message.pdata = data; |
210 { | 210 { |
211 base::AutoLock auto_lock(lock_); | 211 base::AutoLock auto_lock(lock_); |
212 task_id = ++last_task_id_; | 212 task_id = ++last_task_id_; |
213 messages_.insert(std::pair<int, rtc::Message>(task_id, message)); | 213 messages_.insert(std::pair<int, talk_base::Message>(task_id, message)); |
214 } | 214 } |
215 | 215 |
216 if (delay_ms <= 0) { | 216 if (delay_ms <= 0) { |
217 task_runner_->PostTask(FROM_HERE, | 217 task_runner_->PostTask(FROM_HERE, |
218 base::Bind(&JingleThreadWrapper::RunTask, | 218 base::Bind(&JingleThreadWrapper::RunTask, |
219 weak_ptr_, task_id)); | 219 weak_ptr_, task_id)); |
220 } else { | 220 } else { |
221 task_runner_->PostDelayedTask(FROM_HERE, | 221 task_runner_->PostDelayedTask(FROM_HERE, |
222 base::Bind(&JingleThreadWrapper::RunTask, | 222 base::Bind(&JingleThreadWrapper::RunTask, |
223 weak_ptr_, task_id), | 223 weak_ptr_, task_id), |
224 base::TimeDelta::FromMilliseconds(delay_ms)); | 224 base::TimeDelta::FromMilliseconds(delay_ms)); |
225 } | 225 } |
226 } | 226 } |
227 | 227 |
228 void JingleThreadWrapper::RunTask(int task_id) { | 228 void JingleThreadWrapper::RunTask(int task_id) { |
229 bool have_message = false; | 229 bool have_message = false; |
230 rtc::Message message; | 230 talk_base::Message message; |
231 { | 231 { |
232 base::AutoLock auto_lock(lock_); | 232 base::AutoLock auto_lock(lock_); |
233 MessagesQueue::iterator it = messages_.find(task_id); | 233 MessagesQueue::iterator it = messages_.find(task_id); |
234 if (it != messages_.end()) { | 234 if (it != messages_.end()) { |
235 have_message = true; | 235 have_message = true; |
236 message = it->second; | 236 message = it->second; |
237 messages_.erase(it); | 237 messages_.erase(it); |
238 } | 238 } |
239 } | 239 } |
240 | 240 |
241 if (have_message) { | 241 if (have_message) { |
242 if (message.message_id == rtc::MQID_DISPOSE) { | 242 if (message.message_id == talk_base::MQID_DISPOSE) { |
243 DCHECK(message.phandler == NULL); | 243 DCHECK(message.phandler == NULL); |
244 delete message.pdata; | 244 delete message.pdata; |
245 } else { | 245 } else { |
246 message.phandler->OnMessage(&message); | 246 message.phandler->OnMessage(&message); |
247 } | 247 } |
248 } | 248 } |
249 } | 249 } |
250 | 250 |
251 // All methods below are marked as not reached. See comments in the | 251 // All methods below are marked as not reached. See comments in the |
252 // header for more details. | 252 // header for more details. |
253 void JingleThreadWrapper::Quit() { | 253 void JingleThreadWrapper::Quit() { |
254 NOTREACHED(); | 254 NOTREACHED(); |
255 } | 255 } |
256 | 256 |
257 bool JingleThreadWrapper::IsQuitting() { | 257 bool JingleThreadWrapper::IsQuitting() { |
258 NOTREACHED(); | 258 NOTREACHED(); |
259 return false; | 259 return false; |
260 } | 260 } |
261 | 261 |
262 void JingleThreadWrapper::Restart() { | 262 void JingleThreadWrapper::Restart() { |
263 NOTREACHED(); | 263 NOTREACHED(); |
264 } | 264 } |
265 | 265 |
266 bool JingleThreadWrapper::Get(rtc::Message*, int, bool) { | 266 bool JingleThreadWrapper::Get(talk_base::Message*, int, bool) { |
267 NOTREACHED(); | 267 NOTREACHED(); |
268 return false; | 268 return false; |
269 } | 269 } |
270 | 270 |
271 bool JingleThreadWrapper::Peek(rtc::Message*, int) { | 271 bool JingleThreadWrapper::Peek(talk_base::Message*, int) { |
272 NOTREACHED(); | 272 NOTREACHED(); |
273 return false; | 273 return false; |
274 } | 274 } |
275 | 275 |
276 void JingleThreadWrapper::PostAt(uint32, rtc::MessageHandler*, | 276 void JingleThreadWrapper::PostAt(uint32, talk_base::MessageHandler*, |
277 uint32, rtc::MessageData*) { | 277 uint32, talk_base::MessageData*) { |
278 NOTREACHED(); | 278 NOTREACHED(); |
279 } | 279 } |
280 | 280 |
281 void JingleThreadWrapper::Dispatch(rtc::Message* message) { | 281 void JingleThreadWrapper::Dispatch(talk_base::Message* message) { |
282 NOTREACHED(); | 282 NOTREACHED(); |
283 } | 283 } |
284 | 284 |
285 void JingleThreadWrapper::ReceiveSends() { | 285 void JingleThreadWrapper::ReceiveSends() { |
286 NOTREACHED(); | 286 NOTREACHED(); |
287 } | 287 } |
288 | 288 |
289 int JingleThreadWrapper::GetDelay() { | 289 int JingleThreadWrapper::GetDelay() { |
290 NOTREACHED(); | 290 NOTREACHED(); |
291 return 0; | 291 return 0; |
292 } | 292 } |
293 | 293 |
294 void JingleThreadWrapper::Stop() { | 294 void JingleThreadWrapper::Stop() { |
295 NOTREACHED(); | 295 NOTREACHED(); |
296 } | 296 } |
297 | 297 |
298 void JingleThreadWrapper::Run() { | 298 void JingleThreadWrapper::Run() { |
299 NOTREACHED(); | 299 NOTREACHED(); |
300 } | 300 } |
301 | 301 |
302 } // namespace jingle_glue | 302 } // namespace jingle_glue |
OLD | NEW |