Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/base/task.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/task.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/taskrunner.h"
 
 namespace rtc {
 
 int32_t Task::unique_id_seed_ = 0;
 
 Task::Task(TaskParent *parent)
     : TaskParent(this, parent),
       state_(STATE_INIT),
       blocked_(false),
       done_(false),
       aborted_(false),
       busy_(false),
       error_(false),
       start_time_(0),
       timeout_time_(0),
       timeout_seconds_(0),
       timeout_suspended_(false)  {
   unique_id_ = unique_id_seed_++;
 
   // sanity check that we didn't roll-over our id seed
-  ASSERT(unique_id_ < unique_id_seed_);
+  RTC_DCHECK(unique_id_ < unique_id_seed_);
 }
 
 Task::~Task() {
   // Is this task being deleted in the correct manner?
-  ASSERT(!done_ || GetRunner()->is_ok_to_delete(this));
-  ASSERT(state_ == STATE_INIT || done_);
-  ASSERT(state_ == STATE_INIT || blocked_);
+#if RTC_DCHECK_IS_ON
+  RTC_DCHECK(!done_ || GetRunner()->is_ok_to_delete(this));
+#endif
+  RTC_DCHECK(state_ == STATE_INIT || done_);
+  RTC_DCHECK(state_ == STATE_INIT || blocked_);
 
   // If the task is being deleted without being done, it
   // means that it hasn't been removed from its parent.
   // This happens if a task is deleted outside of TaskRunner.
   if (!done_) {
     Stop();
   }
 }
 
 int64_t Task::CurrentTime() {
   return GetRunner()->CurrentTime();
 }
 
 int64_t Task::ElapsedTime() {
   return CurrentTime() - start_time_;
 }
 
 void Task::Start() {
   if (state_ != STATE_INIT)
     return;
   // Set the start time before starting the task.  Otherwise if the task
   // finishes quickly and deletes the Task object, setting start_time_
   // will crash.
   start_time_ = CurrentTime();
   GetRunner()->StartTask(this);
 }
 
 void Task::Step() {
   if (done_) {
-#if !defined(NDEBUG)
+#if RTC_DCHECK_IS_ON
     // we do not know how !blocked_ happens when done_ - should be impossible.
     // But it causes problems, so in retail build, we force blocked_, and
     // under debug we assert.
-    ASSERT(blocked_);
+    RTC_DCHECK(blocked_);
 #else
     blocked_ = true;
 #endif
     return;
   }
 
   // Async Error() was called
   if (error_) {
     done_ = true;
     state_ = STATE_ERROR;
     blocked_ = true;
 //   obsolete - an errored task is not considered done now
 //   SignalDone();
 
     Stop();
-#if !defined(NDEBUG)
+#if RTC_DCHECK_IS_ON
     // verify that stop removed this from its parent
-    ASSERT(!parent()->IsChildTask(this));
+    RTC_DCHECK(!parent()->IsChildTask(this));
 #endif
     return;
   }
 
   busy_ = true;
   int new_state = Process(state_);
   busy_ = false;
 
   if (aborted_) {
     Abort(true);  // no need to wake because we're awake
@@ skipping 14 matching lines @@
   } else if (new_state == STATE_ERROR) {
     done_ = true;
     error_ = true;
   }
 
   if (done_) {
 //  obsolete - call this yourself
 //    SignalDone();
 
     Stop();
-#if !defined(NDEBUG)
+#if RTC_DCHECK_IS_ON
     // verify that stop removed this from its parent
-    ASSERT(!parent()->IsChildTask(this));
+    RTC_DCHECK(!parent()->IsChildTask(this));
 #endif
     blocked_ = true;
   }
 }
 
 void Task::Abort(bool nowake) {
   // Why only check for done_ (instead of "aborted_ || done_")?
   //
   // If aborted_ && !done_, it means the logic for aborting still
   // needs to be executed (because busy_ must have been true when
   // Abort() was previously called).
   if (done_)
     return;
   aborted_ = true;
   if (!busy_) {
     done_ = true;
     blocked_ = true;
     error_ = true;
 
     // "done_" is set before calling "Stop()" to ensure that this code 
     // doesn't execute more than once (recursively) for the same task.
     Stop();
-#if !defined(NDEBUG)
+#if RTC_DCHECK_IS_ON
     // verify that stop removed this from its parent
-    ASSERT(!parent()->IsChildTask(this));
+    RTC_DCHECK(!parent()->IsChildTask(this));
 #endif
     if (!nowake) {
       // WakeTasks to self-delete.
       // Don't call Wake() because it is a no-op after "done_" is set.
       // Even if Wake() did run, it clears "blocked_" which isn't desireable.
       GetRunner()->WakeTasks();
     }
   }
 }
 
@@ skipping 106 matching lines @@
     ResetTimeout();
   }
 }
 
 int Task::OnTimeout() {
   // by default, we are finished after timing out
   return STATE_DONE;
 }
 
 } // namespace rtc