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)
+    : TaskParent(this),
+      next_timeout_task_(NULL),
+      tasks_running_(false)
+#if RTC_DCHECK_IS_ON
+      ,

[kwiberg-webrtc, 2017/01/12 02:10:41]

You may want to use default member initializers to avoid this syntax wart...

[nisse-webrtc, 2017/01/12 10:53:24]

Could make sense, but not in this cl.

Not sure if there's a consensus on using explicit constructor or initializers at
the declaration. At least, we shouldn't mix in the same class. 

[kwiberg-webrtc, 2017/01/12 11:00:38]

I believe you can use either (but preferably not a mix, as you say). And in this
case using default member initializers is clearly a win, since you can entirely
get rid of this #if block with the ugly comma issue.

Follow-up CL? :-)

[nisse-webrtc, 2017/01/12 11:09:42]

I'll change to using initializers, to make it less ugly. But my preferred
followup cl is https://codereview.webrtc.org/2622923002/, deleting all of this,
it's totally unused in webrtc. Unfortunately, it's used by the xmpp code which
was recently moved from webrtc to chrome.

[kwiberg-webrtc, 2017/01/12 12:54:30]

Ah. Good that we're finally about to get serious with moving all supported stuff
to the api/ directory, then, so that we'll eventually stop running into this
sort of stuff.

+      abort_count_(0),
+      deleting_task_(NULL)
 #endif
 {
 }
 
 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