Annotate the intentional test-only leak in base/tracked_objects.cc.

base/tracked_objects.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/tracked_objects.h"
 
 #include <math.h>
 #include <stdlib.h>
 
 #include "base/compiler_specific.h"
+#include "base/debug/leak_annotations.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process_util.h"
 #include "base/profiler/alternate_timer.h"
 #include "base/stringprintf.h"
 #include "base/third_party/valgrind/memcheck.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/port.h"
 
 using base::TimeDelta;
@@ skipping 750 matching lines @@
   if (worker_thread_data_creation_count_ == 0)
     return;  // We haven't really run much, and couldn't have leaked.
   // Verify that we've at least shutdown/cleanup the major namesd threads.  The
   // caller should tell us how many thread shutdowns should have taken place by
   // now.
   return;  // TODO(jar): until this is working on XP, don't run the real test.
   CHECK_GT(cleanup_count_, major_threads_shutdown_count);
 }
 
 // static
 void ThreadData::ShutdownSingleThreadedCleanup(bool leak) {

[jar (doing other things), 2013/06/08 00:24:15]

This function is *only* called during cleanup, which is ONLY called during
tests.

In most uses (real runs of chrome), this is never called, and is actually not
compiled into the final binary.

We do, in those cases, leak all data that was allocated, as we can't tell what
thread is alive and still using the data structures :-(.

The good news is that the total amount of data is well bounded (although with
efforts to support worker threads, we may have raised the bar above the initial
calculations... but the count of worker threads is still bounded.. so it all
stays pretty finite).

   // 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(DEACTIVATED))
     return;
   ThreadData* thread_data_list;
   {
     base::AutoLock lock(*list_lock_.Pointer());
     thread_data_list = all_thread_data_list_head_;
     all_thread_data_list_head_ = NULL;
     ++incarnation_counter_;
     // To be clean, break apart the retired worker list (though we leak them).
     while (first_retired_worker_) {
       ThreadData* worker = first_retired_worker_;
       CHECK_GT(worker->worker_thread_number_, 0);
       first_retired_worker_ = worker->next_retired_worker_;
       worker->next_retired_worker_ = NULL;
     }
   }
 
   // Put most global static back in pristine shape.
   worker_thread_data_creation_count_ = 0;
   cleanup_count_ = 0;
   tls_index_.Set(NULL);
   status_ = DORMANT_DURING_TESTS;  // Almost UNINITIALIZED.
 
   // To avoid any chance of racing in unit tests, which is the only place we
   // 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)
+  if (leak) {
+    ThreadData* thread_data = thread_data_list;
+    while (thread_data) {
+      ANNOTATE_LEAKING_OBJECT_PTR(thread_data);
+      thread_data = thread_data->next();
+    }
     return;
+  }
 
   // When we want to cleanup (on a single thread), here is what we do.
 
   // Do actual recursive delete in all ThreadData instances.
   while (thread_data_list) {
     ThreadData* next_thread_data = thread_data_list;
     thread_data_list = thread_data_list->next();
 
     for (BirthMap::iterator it = next_thread_data->birth_map_.begin();
          next_thread_data->birth_map_.end() != it; ++it)
@@ skipping 40 matching lines @@
     : process_id(base::GetCurrentProcId()) {
 #else
     : process_id(0) {
 #endif
 }
 
 ProcessDataSnapshot::~ProcessDataSnapshot() {
 }
 
 }  // namespace tracked_objects