Reduce leaking in object tracking tests

base/tracked_objects.cc

 // Copyright (c) 2011 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/tracked_objects.h"
 
 #include <math.h>
 
 #include "base/format_macros.h"
 #include "base/message_loop.h"
@@ skipping 524 matching lines @@
 }
 
 // static
 TrackedTime ThreadData::Now() {
   if (kTrackAllTaskObjects && tracking_status())
     return TrackedTime::Now();
   return TrackedTime();  // Super fast when disabled, or not compiled.
 }
 
 // static
-void ThreadData::ShutdownSingleThreadedCleanup() {
+void ThreadData::ShutdownSingleThreadedCleanup(bool leak) {
   // This is only called from test code, where we need to cleanup so that
   // additional tests can be run.
   // We must be single threaded... but be careful anyway.
   if (!InitializeAndSetTrackingStatus(false))
     return;
   ThreadData* thread_data_list;
   ThreadDataPool* final_pool;
   {
     base::AutoLock lock(*list_lock_);
     thread_data_list = all_thread_data_list_head_;
     all_thread_data_list_head_ = NULL;
     final_pool = unregistered_thread_data_pool_;
     unregistered_thread_data_pool_ = NULL;
   }
 
   // Put most global static back in pristine shape.
   thread_number_counter_ = 0;
   tls_index_.Set(NULL);
   status_ = UNINITIALIZED;
 
   // To avoid any chance of racing in unit tests, which is the only place we
-  // call this function, we will leak all the data structures we recovered.
-  // These structures could plausibly be used by other threads in earlier tests
-  // that are still running.
-  return;
+  // call this function, we may sometimes leak all the data structures we
+  // recovered, as they may still be in use on threads from prior tests!
+  if (leak)
+    return;
 
-  // If we wanted to cleanup (on a single thread), here is what we would do.
+  // When we want to cleanup (on a single thread), here is what we do.
 
   if (final_pool) {
     // The thread_data_list contains *all* the instances, and we'll use it to
     // delete them.  This pool has pointers to some instances, and we just
     // have to drop those pointers (and not do the deletes here).
     while (!final_pool->empty())
       final_pool->pop();
     delete final_pool;
   }
 
@@ skipping 552 matching lines @@
                         (combined_selectors_ & BIRTH_THREAD) ? "*" :
                           sample.birth().birth_thread()->thread_name().c_str(),
                         (combined_selectors_ & DEATH_THREAD) ? "*" :
                           sample.DeathThreadName().c_str());
   sample.birth().location().Write(!(combined_selectors_ & BIRTH_FILE),
                                   !(combined_selectors_ & BIRTH_FUNCTION),
                                   output);
 }
 
 }  // namespace tracked_objects