Delete tasks unconditionally in MessageLoop::DeletePendingTasks().

base/message_loop.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/message_loop.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/histogram.h"
@@ skipping 448 matching lines @@
   bool did_work = !work_queue_.empty();
   while (!work_queue_.empty()) {
     PendingTask pending_task = work_queue_.front();
     work_queue_.pop();
     if (!pending_task.delayed_run_time.is_null()) {
       // We want to delete delayed tasks in the same order in which they would
       // normally be deleted in case of any funny dependencies between delayed
       // tasks.
       AddToDelayedWorkQueue(pending_task);
     } else {
-      // TODO(darin): Delete all tasks once it is safe to do so.
-      // Until it is totally safe, just do it when running Purify or
-      // Valgrind.
-#if defined(PURIFY)
       delete pending_task.task;
-#elif defined(OS_POSIX)
-      if (RUNNING_ON_VALGRIND)
-        delete pending_task.task;
-#endif  // defined(OS_POSIX)
     }
   }
   did_work |= !deferred_non_nestable_work_queue_.empty();
   while (!deferred_non_nestable_work_queue_.empty()) {
-    // TODO(darin): Delete all tasks once it is safe to do so.
-    // Until it is totaly safe, only delete them under Purify and Valgrind.
-    Task* task = NULL;
-#if defined(PURIFY)
-    task = deferred_non_nestable_work_queue_.front().task;
-#elif defined(OS_POSIX)
-    if (RUNNING_ON_VALGRIND)
-      task = deferred_non_nestable_work_queue_.front().task;
-#endif
+    delete deferred_non_nestable_work_queue_.front().task;
     deferred_non_nestable_work_queue_.pop();
-    if (task)
-      delete task;
   }
   did_work |= !delayed_work_queue_.empty();
   while (!delayed_work_queue_.empty()) {
-    Task* task = delayed_work_queue_.top().task;
+    delete delayed_work_queue_.top().task;

[jar (doing other things), 2010/08/03 02:40:35]

A task deletion may have a side effect, which may push a new task onto a queue. 
As a result, you have to remove it from the queue before calling for the
deletion.  This was all carefully done in the existing code, and you should try
to maintain that format (removing only the ifdefs.

     delayed_work_queue_.pop();
-    delete task;
   }
   return did_work;
 }
 
 bool MessageLoop::DoWork() {
   if (!nestable_tasks_allowed_) {
     // Task can't be executed right now.
     return false;
   }
 
@@ skipping 168 matching lines @@
                                            Watcher *delegate) {
   return pump_libevent()->WatchFileDescriptor(
       fd,
       persistent,
       static_cast<base::MessagePumpLibevent::Mode>(mode),
       controller,
       delegate);
 }
 
 #endif