base: Remove should_leak_tasks_ from MessageLoop

base/message_loop.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 112 matching lines @@
 }
 
 //------------------------------------------------------------------------------
 
 MessageLoop::MessageLoop(Type type)
     : type_(type),
       nestable_tasks_allowed_(true),
       exception_restoration_(false),
       message_histogram_(NULL),
       state_(NULL),
-      should_leak_tasks_(true),
 #ifdef OS_WIN
       os_modal_loop_(false),
 #endif  // OS_WIN
       next_sequence_num_(0) {
   DCHECK(!current()) << "should only have one message loop per thread";
   lazy_tls_ptr.Pointer()->Set(this);
 
   message_loop_proxy_ = new base::MessageLoopProxyImpl();
 
 // TODO(rvargas): Get rid of the OS guards.
@@ skipping 358 matching lines @@
     base::AutoLock lock(incoming_queue_lock_);
     if (incoming_queue_.empty())
       return;
     incoming_queue_.Swap(&work_queue_);  // Constant time
     DCHECK(incoming_queue_.empty());
   }
 }
 
 bool MessageLoop::DeletePendingTasks() {
   bool did_work = !work_queue_.empty();
-  // TODO(darin): Delete all tasks once it is safe to do so.
-  // Until it is totally safe, just do it when running Valgrind.
-  //
-  // See http://crbug.com/61131
-  //
-#if defined(USE_HEAPCHECKER)
-  should_leak_tasks_ = false;
-#else
-      if (RunningOnValgrind())
-        should_leak_tasks_ = false;
-#endif  // defined(OS_POSIX)
   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);
     }
   }
   did_work |= !deferred_non_nestable_work_queue_.empty();
   while (!deferred_non_nestable_work_queue_.empty()) {
     deferred_non_nestable_work_queue_.pop();
   }
   did_work |= !delayed_work_queue_.empty();
 
   // Historically, we always delete the task regardless of valgrind status. It's
   // not completely clear why we want to leak them in the loops above.  This
   // code is replicating legacy behavior, and should not be considered
   // absolutely "correct" behavior.  See TODO above about deleting all tasks
   // when it's safe.
-  should_leak_tasks_ = false;
   while (!delayed_work_queue_.empty()) {
     delayed_work_queue_.pop();
   }
-  should_leak_tasks_ = true;
   return did_work;
 }
 
 TimeTicks MessageLoop::CalculateDelayedRuntime(int64 delay_ms) {
   TimeTicks delayed_run_time;
   if (delay_ms > 0) {
     delayed_run_time =
         TimeTicks::Now() + TimeDelta::FromMilliseconds(delay_ms);
 
 #if defined(OS_WIN)
@@ skipping 248 matching lines @@
                                            Watcher *delegate) {
   return pump_libevent()->WatchFileDescriptor(
       fd,
       persistent,
       static_cast<base::MessagePumpLibevent::Mode>(mode),
       controller,
       delegate);
 }
 
 #endif