1 /* 2 * Copyright 2004 The WebRTC Project Authors. All rights reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include "webrtc/base/signalthread.h" 12 13 #include "webrtc/base/common.h" 14 15 namespace rtc { 16 17 /////////////////////////////////////////////////////////////////////////////// 18 // SignalThread 19 /////////////////////////////////////////////////////////////////////////////// 20 21 SignalThread::SignalThread() 22 : main_(Thread::Current()), 23 worker_(this), 24 state_(kInit), 25 refcount_(1) { 26 main_->SignalQueueDestroyed.connect(this, 27 &SignalThread::OnMainThreadDestroyed); 28 worker_.SetName("SignalThread", this); 29 } 30 31 SignalThread::~SignalThread() { 32 ASSERT(refcount_ == 0); 33 } 34 35 bool SignalThread::SetName(const std::string& name, const void* obj) { 36 EnterExit ee(this); 37 ASSERT(main_->IsCurrent()); 38 ASSERT(kInit == state_); 39 return worker_.SetName(name, obj); 40 } 41 42 bool SignalThread::SetPriority(ThreadPriority priority) { 43 EnterExit ee(this); 44 ASSERT(main_->IsCurrent()); 45 ASSERT(kInit == state_); 46 return worker_.SetPriority(priority); 47 } 48 49 void SignalThread::Start() { 50 EnterExit ee(this); 51 ASSERT(main_->IsCurrent()); 52 if (kInit == state_ || kComplete == state_) { 53 state_ = kRunning; 54 OnWorkStart(); 55 worker_.Start(); 56 } else { 57 ASSERT(false); 58 } 59 } 60 61 void SignalThread::Destroy(bool wait) { 62 EnterExit ee(this); 63 ASSERT(main_->IsCurrent()); 64 if ((kInit == state_) || (kComplete == state_)) { 65 refcount_--; 66 } else if (kRunning == state_ || kReleasing == state_) { 67 state_ = kStopping; 68 // OnWorkStop() must follow Quit(), so that when the thread wakes up due to 69 // OWS(), ContinueWork() will return false. 70 worker_.Quit(); 71 OnWorkStop(); 72 if (wait) { 73 // Release the thread's lock so that it can return from ::Run. 74 cs_.Leave(); 75 worker_.Stop(); 76 cs_.Enter(); 77 refcount_--; 78 } 79 } else { 80 ASSERT(false); 81 } 82 } 83 84 void SignalThread::Release() { 85 EnterExit ee(this); 86 ASSERT(main_->IsCurrent()); 87 if (kComplete == state_) { 88 refcount_--; 89 } else if (kRunning == state_) { 90 state_ = kReleasing; 91 } else { 92 // if (kInit == state_) use Destroy() 93 ASSERT(false); 94 } 95 } 96 97 bool SignalThread::ContinueWork() { 98 EnterExit ee(this); 99 ASSERT(worker_.IsCurrent()); 100 return worker_.ProcessMessages(0); 101 } 102 103 void SignalThread::OnMessage(Message *msg) { 104 EnterExit ee(this); 105 if (ST_MSG_WORKER_DONE == msg->message_id) { 106 ASSERT(main_->IsCurrent()); 107 OnWorkDone(); 108 bool do_delete = false; 109 if (kRunning == state_) { 110 state_ = kComplete; 111 } else { 112 do_delete = true; 113 } 114 if (kStopping != state_) { 115 // Before signaling that the work is done, make sure that the worker 116 // thread actually is done. We got here because DoWork() finished and 117 // Run() posted the ST_MSG_WORKER_DONE message. This means the worker 118 // thread is about to go away anyway, but sometimes it doesn't actually 119 // finish before SignalWorkDone is processed, and for a reusable 120 // SignalThread this makes an assert in thread.cc fire. 121 // 122 // Calling Stop() on the worker ensures that the OS thread that underlies 123 // the worker will finish, and will be set to NULL, enabling us to call 124 // Start() again. 125 worker_.Stop(); 126 SignalWorkDone(this); 127 } 128 if (do_delete) { 129 refcount_--; 130 } 131 } 132 } 133 134 void SignalThread::Run() { 135 DoWork(); 136 { 137 EnterExit ee(this); 138 if (main_) { 139 main_->Post(this, ST_MSG_WORKER_DONE); 140 } 141 } 142 } 143 144 void SignalThread::OnMainThreadDestroyed() { 145 EnterExit ee(this); 146 main_ = NULL; 147 } 148 149 } // namespace rtc 150