Reduce leaking in object tracking tests

base/tracked_objects_unittest.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.
 
 // Test of classes in the tracked_objects.h classes.
 
 #include "base/tracked_objects.h"
 
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace tracked_objects {
 
 class TrackedObjectsTest : public testing::Test {
  public:
   TrackedObjectsTest() {
-    ThreadData::ShutdownSingleThreadedCleanup();
+    // On entry, leak any database structures in case they are still in use by
+    // prior threads.
+    ThreadData::ShutdownSingleThreadedCleanup(true);
   }
 
   ~TrackedObjectsTest() {
-    ThreadData::ShutdownSingleThreadedCleanup();
+    // We should not need to leak any structures we create, since we are
+    // single threaded, and carefully accounting for items.
+    ThreadData::ShutdownSingleThreadedCleanup(false);
   }
 };
 
 TEST_F(TrackedObjectsTest, MinimalStartupShutdown) {
   // Minimal test doesn't even create any tasks.
   if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
   ThreadData* data = ThreadData::Get();
   EXPECT_TRUE(ThreadData::first());  // Now class was constructed.
   EXPECT_TRUE(data);
   EXPECT_TRUE(!data->next());
   EXPECT_EQ(data, ThreadData::Get());
   ThreadData::BirthMap birth_map;
   data->SnapshotBirthMap(&birth_map);
   EXPECT_EQ(0u, birth_map.size());
   ThreadData::DeathMap death_map;
   data->SnapshotDeathMap(&death_map);
   EXPECT_EQ(0u, death_map.size());
-  ThreadData::ShutdownSingleThreadedCleanup();
+  // Cleanup with no leaking.
+  ThreadData::ShutdownSingleThreadedCleanup(false);
 
   // Do it again, just to be sure we reset state completely.
   ThreadData::InitializeAndSetTrackingStatus(true);
   EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
   data = ThreadData::Get();
   EXPECT_TRUE(ThreadData::first());  // Now class was constructed.
   EXPECT_TRUE(data);
   EXPECT_TRUE(!data->next());
   EXPECT_EQ(data, ThreadData::Get());
   birth_map.clear();
@@ skipping 76 matching lines @@
   EXPECT_EQ(data->queue_duration(), queue_duration + queue_duration);
   EXPECT_EQ(data->AverageMsRunDuration(), run_ms);
   EXPECT_EQ(data->AverageMsQueueDuration(), queue_ms);
   EXPECT_EQ(data->count(), 2);
 
   scoped_ptr<base::DictionaryValue> dictionary(data->ToValue());
   int integer;
   EXPECT_TRUE(dictionary->GetInteger("run_ms", &integer));
   EXPECT_EQ(integer, 2 * run_ms);
   EXPECT_TRUE(dictionary->GetInteger("queue_ms", &integer));
-  EXPECT_EQ(integer, 2* queue_ms);
+  EXPECT_EQ(integer, 2 * queue_ms);
   EXPECT_TRUE(dictionary->GetInteger("count", &integer));
   EXPECT_EQ(integer, 2);
 
   std::string output;
   data->WriteHTML(&output);
   std::string results = "Lives:2, Run:84ms(42ms/life) Queue:16ms(8ms/life) ";
   EXPECT_EQ(output, results);
 
   scoped_ptr<base::Value> value(data->ToValue());
   std::string json;
@@ skipping 442 matching lines @@
             "\"function_name\":\"DifferentLives\","
             "\"line_number\":999"
           "}"
         "}"
       "]"
     "}";
   EXPECT_EQ(one_line_result, json);
 }
 
 }  // namespace tracked_objects