Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/base/taskrunner.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 <algorithm>
 
 #include "webrtc/base/taskrunner.h"
 
+#include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/task.h"
 #include "webrtc/base/logging.h"
 
 namespace rtc {
 
 TaskRunner::TaskRunner()
-  : TaskParent(this),
-    next_timeout_task_(NULL),
-    tasks_running_(false)
-#if !defined(NDEBUG)
-    , abort_count_(0),
-    deleting_task_(NULL)
-#endif
-{
-}
+    : TaskParent(this) {}
 
 TaskRunner::~TaskRunner() {
   // this kills and deletes children silently!
   AbortAllChildren();
   InternalRunTasks(true);
 }
 
 void TaskRunner::StartTask(Task * task) {
   tasks_.push_back(task);
 
   // the task we just started could be about to timeout --
   // make sure our "next timeout task" is correct
   UpdateTaskTimeout(task, 0);
 
   WakeTasks();
 }
 
 void TaskRunner::RunTasks() {
   InternalRunTasks(false);
 }
 
 void TaskRunner::InternalRunTasks(bool in_destructor) {
   // This shouldn't run while an abort is happening.
   // If that occurs, then tasks may be deleted in this method,
   // but pointers to them will still be in the
   // "ChildSet copy" in TaskParent::AbortAllChildren.
-  // Subsequent use of those task may cause data corruption or crashes.  
-  ASSERT(!abort_count_);
+  // Subsequent use of those task may cause data corruption or crashes.
+#if RTC_DCHECK_IS_ON
+  RTC_DCHECK(!abort_count_);
+#endif
   // Running continues until all tasks are Blocked (ok for a small # of tasks)
   if (tasks_running_) {
     return;  // don't reenter
   }
 
   tasks_running_ = true;
 
   int64_t previous_timeout_time = next_task_timeout();
 
   int did_run = true;
@@ skipping 11 matching lines @@
   bool need_timeout_recalc = false;
   for (size_t i = 0; i < tasks_.size(); ++i) {
     if (tasks_[i]->IsDone()) {
       Task* task = tasks_[i];
       if (next_timeout_task_ &&
           task->unique_id() == next_timeout_task_->unique_id()) {
         next_timeout_task_ = NULL;
         need_timeout_recalc = true;
       }
 
-#if !defined(NDEBUG)
+#if RTC_DCHECK_IS_ON
       deleting_task_ = task;
 #endif
       delete task;
-#if !defined(NDEBUG)
+#if RTC_DCHECK_IS_ON
       deleting_task_ = NULL;
 #endif
       tasks_[i] = NULL;
     }
   }
   // Finally, remove nulls
   std::vector<Task *>::iterator it;
   it = std::remove(tasks_.begin(),
                    tasks_.end(),
                    reinterpret_cast<Task *>(NULL));
@@ skipping 38 matching lines @@
 
 // this function gets called frequently -- when each task changes
 // state to something other than DONE, ERROR or BLOCKED, it calls
 // ResetTimeout(), which will call this function to make sure that
 // the next timeout-able task hasn't changed.  The logic in this function
 // prevents RecalcNextTimeout() from getting called in most cases,
 // effectively making the task scheduler O-1 instead of O-N
 
 void TaskRunner::UpdateTaskTimeout(Task* task,
                                    int64_t previous_task_timeout_time) {
-  ASSERT(task != NULL);
+  RTC_DCHECK(task != NULL);
   int64_t previous_timeout_time = next_task_timeout();
   bool task_is_timeout_task = next_timeout_task_ != NULL &&
       task->unique_id() == next_timeout_task_->unique_id();
   if (task_is_timeout_task) {
     previous_timeout_time = previous_task_timeout_time;
   }
 
   // if the relevant task has a timeout, then
   // check to see if it's closer than the current
   // "about to timeout" task
@@ skipping 50 matching lines @@
   bool timeout_change = (previous_timeout_time == 0 && next_timeout != 0) ||
       next_timeout < previous_timeout_time ||
       (previous_timeout_time <= CurrentTime() &&
        previous_timeout_time != next_timeout);
   if (timeout_change) {
     OnTimeoutChange();
   }
 }
 
 } // namespace rtc