Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/base/thread.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/base/thread.h"
 
 #ifndef __has_feature
 #define __has_feature(x) 0  // Compatibility with non-clang or LLVM compilers.
 #endif  // __has_feature
 
 #if defined(WEBRTC_WIN)
 #include <comdef.h>
 #elif defined(WEBRTC_POSIX)
 #include <time.h>
 #endif
 
+#include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/nullsocketserver.h"
 #include "webrtc/base/platform_thread.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/trace_event.h"
 
 #if !__has_feature(objc_arc) && (defined(WEBRTC_MAC))
 #include "webrtc/base/maccocoathreadhelper.h"
@@ skipping 94 matching lines @@
   Thread* thread;
   Runnable* runnable;
 };
 
 Thread::ScopedDisallowBlockingCalls::ScopedDisallowBlockingCalls()
   : thread_(Thread::Current()),
     previous_state_(thread_->SetAllowBlockingCalls(false)) {
 }
 
 Thread::ScopedDisallowBlockingCalls::~ScopedDisallowBlockingCalls() {
-  ASSERT(thread_->IsCurrent());
+  RTC_DCHECK(thread_->IsCurrent());
   thread_->SetAllowBlockingCalls(previous_state_);
 }
 
 Thread::Thread() : Thread(SocketServer::CreateDefault()) {}
 
 Thread::Thread(SocketServer* ss)
     : MessageQueue(ss, false),
       running_(true, false),
 #if defined(WEBRTC_WIN)
       thread_(NULL),
@@ skipping 58 matching lines @@
   name_ = name;
   if (obj) {
     char buf[16];
     sprintfn(buf, sizeof(buf), " 0x%p", obj);
     name_ += buf;
   }
   return true;
 }
 
 bool Thread::Start(Runnable* runnable) {
-  ASSERT(owned_);
+  RTC_DCHECK(owned_);
   if (!owned_) return false;
-  ASSERT(!running());
+  RTC_DCHECK(!running());
   if (running()) return false;
 
   Restart();  // reset IsQuitting() if the thread is being restarted
 
   // Make sure that ThreadManager is created on the main thread before
   // we start a new thread.
   ThreadManager::Instance();
 
   ThreadInit* init = new ThreadInit;
   init->thread = this;
@@ skipping 37 matching lines @@
 #endif
   running_.Reset();
 }
 
 void Thread::SafeWrapCurrent() {
   WrapCurrentWithThreadManager(ThreadManager::Instance(), false);
 }
 
 void Thread::Join() {
   if (running()) {
-    ASSERT(!IsCurrent());
+    RTC_DCHECK(!IsCurrent());
     if (Current() && !Current()->blocking_calls_allowed_) {
       LOG(LS_WARNING) << "Waiting for the thread to join, "
                       << "but blocking calls have been disallowed";
     }
 
 #if defined(WEBRTC_WIN)
-    ASSERT(thread_ != NULL);
+    RTC_DCHECK(thread_ != NULL);
     WaitForSingleObject(thread_, INFINITE);
     CloseHandle(thread_);
     thread_ = NULL;
     thread_id_ = 0;
 #elif defined(WEBRTC_POSIX)
     void *pv;
     pthread_join(thread_, &pv);
 #endif
     running_.Reset();
   }
 }
 
 bool Thread::SetAllowBlockingCalls(bool allow) {
-  ASSERT(IsCurrent());
+  RTC_DCHECK(IsCurrent());
   bool previous = blocking_calls_allowed_;
   blocking_calls_allowed_ = allow;
   return previous;
 }
 
 // static
 void Thread::AssertBlockingIsAllowedOnCurrentThread() {
 #if !defined(NDEBUG)
   Thread* current = Thread::Current();
-  ASSERT(!current || current->blocking_calls_allowed_);
+  RTC_DCHECK(!current || current->blocking_calls_allowed_);
 #endif
 }
 
 void* Thread::PreRun(void* pv) {
   ThreadInit* init = static_cast<ThreadInit*>(pv);
   ThreadManager::Instance()->SetCurrentThread(init->thread);
   rtc::SetCurrentThreadName(init->thread->name_.c_str());
 #if __has_feature(objc_arc)
   @autoreleasepool
 #elif defined(WEBRTC_MAC)
@@ skipping 41 matching lines @@
   msg.pdata = pdata;
   if (IsCurrent()) {
     phandler->OnMessage(&msg);
     return;
   }
 
   AssertBlockingIsAllowedOnCurrentThread();
 
   AutoThread thread;
   Thread *current_thread = Thread::Current();
-  ASSERT(current_thread != NULL);  // AutoThread ensures this
+  RTC_DCHECK(current_thread != NULL);  // AutoThread ensures this
 
   bool ready = false;
   {
     CritScope cs(&crit_);
     _SendMessage smsg;
     smsg.thread = current_thread;
     smsg.msg = msg;
     smsg.ready = &ready;
     sendlist_.push_back(smsg);
   }
@@ skipping 168 matching lines @@
 AutoThread::~AutoThread() {
   Stop();
   if (ThreadManager::Instance()->CurrentThread() == this) {
     ThreadManager::Instance()->SetCurrentThread(NULL);
   }
 }
 
 #if defined(WEBRTC_WIN)
 void ComThread::Run() {
   HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
-  ASSERT(SUCCEEDED(hr));
+  RTC_DCHECK(SUCCEEDED(hr));
   if (SUCCEEDED(hr)) {
     Thread::Run();
     CoUninitialize();
   } else {
     LOG(LS_ERROR) << "CoInitialize failed, hr=" << hr;
   }
 }
 #endif
 
 }  // namespace rtc