Don't use StaticMemorySingletonTraits for TraceLog.

base/debug/trace_event_unittest.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/debug/trace_event_unittest.h"
 
 #include <cstdlib>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 31 matching lines @@
 };
 
 const int kThreadId = 42;
 const int kAsyncId = 5;
 const char kAsyncIdStr[] = "0x5";
 const int kAsyncId2 = 6;
 const char kAsyncId2Str[] = "0x6";
 
 class TraceEventTestFixture : public testing::Test {
  public:
-  // This fixture does not use SetUp() because the fixture must be manually set
-  // up multiple times when testing AtExit. Use ManualTestSetUp for this.
-  void ManualTestSetUp();
   void OnTraceDataCollected(
       const scoped_refptr<base::RefCountedString>& events_str);
   void OnTraceNotification(int notification) {
     if (notification & TraceLog::EVENT_WATCH_NOTIFICATION)
       ++event_watch_notification_;
       notifications_received_ |= notification;
   }
   DictionaryValue* FindMatchingTraceEntry(const JsonKeyValue* key_values);
   DictionaryValue* FindNamePhase(const char* name, const char* phase);
   DictionaryValue* FindNamePhaseKeyValue(const char* name,
@@ skipping 25 matching lines @@
       TraceLog::GetInstance()->SetDisabled();
     TraceLog::GetInstance()->Flush(
         base::Bind(&TraceEventTestFixture::OnTraceDataCollected,
                    base::Unretained(this)));
   }
 
   virtual void SetUp() OVERRIDE {
     const char* name = PlatformThread::GetName();
     old_thread_name_ = name ? strdup(name) : NULL;
     notifications_received_ = 0;
+
+    TraceLog::DeleteForTesting();
+    TraceLog* tracelog = TraceLog::GetInstance();
+    ASSERT_TRUE(tracelog);
+    ASSERT_FALSE(tracelog->IsEnabled());
+    tracelog->SetNotificationCallback(
+        base::Bind(&TraceEventTestFixture::OnTraceNotification,
+                   base::Unretained(this)));
+    trace_buffer_.SetOutputCallback(json_output_.GetCallback());
   }
   virtual void TearDown() OVERRIDE {
     if (TraceLog::GetInstance())
       EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled());
     PlatformThread::SetName(old_thread_name_ ? old_thread_name_ : "");
     free(old_thread_name_);
     old_thread_name_ = NULL;
+    // We want our singleton torn down after each test.
+    TraceLog::DeleteForTesting();
   }
 
   char* old_thread_name_;
   ListValue trace_parsed_;
   base::debug::TraceResultBuffer trace_buffer_;
   base::debug::TraceResultBuffer::SimpleOutput json_output_;
   int event_watch_notification_;
   int notifications_received_;
 
  private:
   // We want our singleton torn down after each test.
   ShadowingAtExitManager at_exit_manager_;
   Lock lock_;
 };
 
-void TraceEventTestFixture::ManualTestSetUp() {
-  TraceLog::DeleteForTesting();
-  TraceLog::Resurrect();
-  TraceLog* tracelog = TraceLog::GetInstance();
-  ASSERT_TRUE(tracelog);
-  ASSERT_FALSE(tracelog->IsEnabled());
-  tracelog->SetNotificationCallback(
-      base::Bind(&TraceEventTestFixture::OnTraceNotification,
-                 base::Unretained(this)));
-  trace_buffer_.SetOutputCallback(json_output_.GetCallback());
-}
-
 void TraceEventTestFixture::OnTraceDataCollected(
     const scoped_refptr<base::RefCountedString>& events_str) {
   AutoLock lock(lock_);
   json_output_.json_output.clear();
   trace_buffer_.Start();
   trace_buffer_.AddFragment(events_str->data());
   trace_buffer_.Finish();
 
   scoped_ptr<Value> root;
   root.reset(base::JSONReader::Read(json_output_.json_output,
@@ skipping 656 matching lines @@
 
 void HighResSleepForTraceTest(base::TimeDelta elapsed) {
   base::TimeTicks end_time = base::TimeTicks::HighResNow() + elapsed;
   do {
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
   } while (base::TimeTicks::HighResNow() < end_time);
 }
 
 // Simple Test for emitting data and validating it was received.
 TEST_F(TraceEventTestFixture, DataCaptured) {
-  ManualTestSetUp();
   TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
                                       TraceLog::RECORD_UNTIL_FULL);
 
   TraceWithAllMacroVariants(NULL);
 
   EndTraceAndFlush();
 
   ValidateAllTraceMacrosCreatedData(trace_parsed_);
 }
 
 class MockEnabledStateChangedObserver :
       public base::debug::TraceLog::EnabledStateObserver {
  public:
   MOCK_METHOD0(OnTraceLogEnabled, void());
   MOCK_METHOD0(OnTraceLogDisabled, void());
 };
 
 TEST_F(TraceEventTestFixture, EnabledObserverFiresOnEnable) {
-  ManualTestSetUp();
-
   MockEnabledStateChangedObserver observer;
   TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
 
   EXPECT_CALL(observer, OnTraceLogEnabled())
       .Times(1);
   TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
                                       TraceLog::RECORD_UNTIL_FULL);
   testing::Mock::VerifyAndClear(&observer);
   EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
 
   // Cleanup.
   TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
   TraceLog::GetInstance()->SetDisabled();
 }
 
 TEST_F(TraceEventTestFixture, EnabledObserverDoesntFireOnSecondEnable) {
-  ManualTestSetUp();
-
   TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
                                       TraceLog::RECORD_UNTIL_FULL);
 
   testing::StrictMock<MockEnabledStateChangedObserver> observer;
   TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
 
   EXPECT_CALL(observer, OnTraceLogEnabled())
       .Times(0);
   EXPECT_CALL(observer, OnTraceLogDisabled())
       .Times(0);
   TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
                                       TraceLog::RECORD_UNTIL_FULL);
   testing::Mock::VerifyAndClear(&observer);
   EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
 
   // Cleanup.
   TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
   TraceLog::GetInstance()->SetDisabled();
   TraceLog::GetInstance()->SetDisabled();
 }
 
 TEST_F(TraceEventTestFixture, EnabledObserverDoesntFireOnNestedDisable) {
-  ManualTestSetUp();
-
   CategoryFilter cf_inc_all("*");
   TraceLog::GetInstance()->SetEnabled(cf_inc_all, TraceLog::RECORD_UNTIL_FULL);
   TraceLog::GetInstance()->SetEnabled(cf_inc_all, TraceLog::RECORD_UNTIL_FULL);
 
   testing::StrictMock<MockEnabledStateChangedObserver> observer;
   TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
 
   EXPECT_CALL(observer, OnTraceLogEnabled())
       .Times(0);
   EXPECT_CALL(observer, OnTraceLogDisabled())
       .Times(0);
   TraceLog::GetInstance()->SetDisabled();
   testing::Mock::VerifyAndClear(&observer);
 
   // Cleanup.
   TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
   TraceLog::GetInstance()->SetDisabled();
 }
 
 TEST_F(TraceEventTestFixture, EnabledObserverFiresOnDisable) {
-  ManualTestSetUp();
-
   TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
                                       TraceLog::RECORD_UNTIL_FULL);
 
   MockEnabledStateChangedObserver observer;
   TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
 
   EXPECT_CALL(observer, OnTraceLogDisabled())
       .Times(1);
   TraceLog::GetInstance()->SetDisabled();
   testing::Mock::VerifyAndClear(&observer);
@@ skipping 13 matching lines @@
   virtual void OnTraceLogEnabled() OVERRIDE {
     EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
   }
 
   virtual void OnTraceLogDisabled() OVERRIDE {
     EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled());
   }
 };
 
 TEST_F(TraceEventTestFixture, ObserversFireAfterStateChange) {
-  ManualTestSetUp();
-
   AfterStateChangeEnabledStateObserver observer;
   TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
 
   TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
                                       TraceLog::RECORD_UNTIL_FULL);
   EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
 
   TraceLog::GetInstance()->SetDisabled();
   EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled());
 
   TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
 }
 
 // Tests that a state observer can remove itself during a callback.
 class SelfRemovingEnabledStateObserver
     : public base::debug::TraceLog::EnabledStateObserver {
  public:
   SelfRemovingEnabledStateObserver() {}
   virtual ~SelfRemovingEnabledStateObserver() {}
 
   // base::debug::TraceLog::EnabledStateObserver overrides:
   virtual void OnTraceLogEnabled() OVERRIDE {}
 
   virtual void OnTraceLogDisabled() OVERRIDE {
     TraceLog::GetInstance()->RemoveEnabledStateObserver(this);
   }
 };
 
 TEST_F(TraceEventTestFixture, SelfRemovingObserver) {
-  ManualTestSetUp();
   ASSERT_EQ(0u, TraceLog::GetInstance()->GetObserverCountForTest());
 
   SelfRemovingEnabledStateObserver observer;
   TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
   EXPECT_EQ(1u, TraceLog::GetInstance()->GetObserverCountForTest());
 
   TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
                                       TraceLog::RECORD_UNTIL_FULL);
   TraceLog::GetInstance()->SetDisabled();
   // The observer removed itself on disable.
   EXPECT_EQ(0u, TraceLog::GetInstance()->GetObserverCountForTest());
 }
 
 bool IsNewTrace() {
   bool is_new_trace;
   TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
   return is_new_trace;
 }
 
 TEST_F(TraceEventTestFixture, NewTraceRecording) {
-  ManualTestSetUp();
   ASSERT_FALSE(IsNewTrace());
   TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
                                       TraceLog::RECORD_UNTIL_FULL);
   // First call to IsNewTrace() should succeed. But, the second shouldn't.
   ASSERT_TRUE(IsNewTrace());
   ASSERT_FALSE(IsNewTrace());
   EndTraceAndFlush();
 
   // IsNewTrace() should definitely be false now.
   ASSERT_FALSE(IsNewTrace());
 
   // Start another trace. IsNewTrace() should become true again, briefly, as
   // before.
   TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
                                       TraceLog::RECORD_UNTIL_FULL);
   ASSERT_TRUE(IsNewTrace());
   ASSERT_FALSE(IsNewTrace());
 
   // Cleanup.
   EndTraceAndFlush();
 }
 
 
 // Test that categories work.
 TEST_F(TraceEventTestFixture, Categories) {
-  ManualTestSetUp();
-
   // Test that categories that are used can be retrieved whether trace was
   // enabled or disabled when the trace event was encountered.
   TRACE_EVENT_INSTANT0("c1", "name", TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("c2", "name", TRACE_EVENT_SCOPE_THREAD);
   BeginTrace();
   TRACE_EVENT_INSTANT0("c3", "name", TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("c4", "name", TRACE_EVENT_SCOPE_THREAD);
   // Category groups containing more than one category.
   TRACE_EVENT_INSTANT0("c5,c6", "name", TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("c7,c8", "name", TRACE_EVENT_SCOPE_THREAD);
@@ skipping 124 matching lines @@
   EndTraceAndFlush();
   EXPECT_TRUE(FindMatchingValue("cat", "inc_wildchar_bla_end"));
   EXPECT_TRUE(FindMatchingValue("cat", "cat1"));
   EXPECT_TRUE(FindMatchingValue("cat", "cat2"));
   EXPECT_FALSE(FindMatchingValue("name", "not_inc"));
 }
 
 
 // Test EVENT_WATCH_NOTIFICATION
 TEST_F(TraceEventTestFixture, EventWatchNotification) {
-  ManualTestSetUp();
-
   // Basic one occurrence.
   BeginTrace();
   TraceLog::GetInstance()->SetWatchEvent("cat", "event");
   TRACE_EVENT_INSTANT0("cat", "event", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_EQ(event_watch_notification_, 1);
 
   // Basic one occurrence before Set.
   BeginTrace();
   TRACE_EVENT_INSTANT0("cat", "event", TRACE_EVENT_SCOPE_THREAD);
@@ skipping 37 matching lines @@
   BeginTrace();
   TraceLog::GetInstance()->SetWatchEvent("cat", "event");
   TraceLog::GetInstance()->CancelWatchEvent();
   TRACE_EVENT_INSTANT0("cat", "event", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_EQ(event_watch_notification_, 0);
 }
 
 // Test ASYNC_BEGIN/END events
 TEST_F(TraceEventTestFixture, AsyncBeginEndEvents) {
-  ManualTestSetUp();
   BeginTrace();
 
   unsigned long long id = 0xfeedbeeffeedbeefull;
   TRACE_EVENT_ASYNC_BEGIN0( "cat", "name1", id);
   TRACE_EVENT_ASYNC_STEP0( "cat", "name1", id, "step1");
   TRACE_EVENT_ASYNC_END0("cat", "name1", id);
   TRACE_EVENT_BEGIN0( "cat", "name2");
   TRACE_EVENT_ASYNC_BEGIN0( "cat", "name3", 0);
 
   EndTraceAndFlush();
 
   EXPECT_TRUE(FindNamePhase("name1", "S"));
   EXPECT_TRUE(FindNamePhase("name1", "T"));
   EXPECT_TRUE(FindNamePhase("name1", "F"));
 
   std::string id_str;
   StringAppendF(&id_str, "0x%llx", id);
 
   EXPECT_TRUE(FindNamePhaseKeyValue("name1", "S", "id", id_str.c_str()));
   EXPECT_TRUE(FindNamePhaseKeyValue("name1", "T", "id", id_str.c_str()));
   EXPECT_TRUE(FindNamePhaseKeyValue("name1", "F", "id", id_str.c_str()));
   EXPECT_TRUE(FindNamePhaseKeyValue("name3", "S", "id", "0x0"));
 
   // BEGIN events should not have id
   EXPECT_FALSE(FindNamePhaseKeyValue("name2", "B", "id", "0"));
 }
 
 // Test ASYNC_BEGIN/END events
 TEST_F(TraceEventTestFixture, AsyncBeginEndPointerMangling) {
-  ManualTestSetUp();
-
   void* ptr = this;
 
   TraceLog::GetInstance()->SetProcessID(100);
   BeginTrace();
   TRACE_EVENT_ASYNC_BEGIN0( "cat", "name1", ptr);
   TRACE_EVENT_ASYNC_BEGIN0( "cat", "name2", ptr);
   EndTraceAndFlush();
 
   TraceLog::GetInstance()->SetProcessID(200);
   BeginTrace();
@@ skipping 17 matching lines @@
   ASSERT_TRUE(value->GetAsString(&async_begin2_id_str));
   ASSERT_TRUE(async_end->Get("id", &value));
   ASSERT_TRUE(value->GetAsString(&async_end_id_str));
 
   EXPECT_STREQ(async_begin_id_str.c_str(), async_begin2_id_str.c_str());
   EXPECT_STRNE(async_begin_id_str.c_str(), async_end_id_str.c_str());
 }
 
 // Test that static strings are not copied.
 TEST_F(TraceEventTestFixture, StaticStringVsString) {
-  ManualTestSetUp();
   TraceLog* tracer = TraceLog::GetInstance();
   // Make sure old events are flushed:
   EndTraceAndFlush();
   EXPECT_EQ(0u, tracer->GetEventsSize());
 
   {
     BeginTrace();
     // Test that string arguments are copied.
     TRACE_EVENT2("cat", "name1",
                  "arg1", std::string("argval"), "arg2", std::string("argval"));
@@ skipping 32 matching lines @@
     EXPECT_STREQ("name1", event1.name());
     EXPECT_STREQ("name2", event2.name());
     EXPECT_TRUE(event1.parameter_copy_storage() == NULL);
     EXPECT_TRUE(event2.parameter_copy_storage() == NULL);
     EndTraceAndFlush();
   }
 }
 
 // Test that data sent from other threads is gathered
 TEST_F(TraceEventTestFixture, DataCapturedOnThread) {
-  ManualTestSetUp();
   BeginTrace();
 
   Thread thread("1");
   WaitableEvent task_complete_event(false, false);
   thread.Start();
 
   thread.message_loop()->PostTask(
       FROM_HERE, base::Bind(&TraceWithAllMacroVariants, &task_complete_event));
   task_complete_event.Wait();
   thread.Stop();
 
   EndTraceAndFlush();
   ValidateAllTraceMacrosCreatedData(trace_parsed_);
 }
 
 // Test that data sent from multiple threads is gathered
 TEST_F(TraceEventTestFixture, DataCapturedManyThreads) {
-  ManualTestSetUp();
   BeginTrace();
 
   const int num_threads = 4;
   const int num_events = 4000;
   Thread* threads[num_threads];
   WaitableEvent* task_complete_events[num_threads];
   for (int i = 0; i < num_threads; i++) {
     threads[i] = new Thread(StringPrintf("Thread %d", i).c_str());
     task_complete_events[i] = new WaitableEvent(false, false);
     threads[i]->Start();
@@ skipping 13 matching lines @@
   }
 
   EndTraceAndFlush();
 
   ValidateInstantEventPresentOnEveryThread(trace_parsed_,
                                            num_threads, num_events);
 }
 
 // Test that thread and process names show up in the trace
 TEST_F(TraceEventTestFixture, ThreadNames) {
-  ManualTestSetUp();
-
   // Create threads before we enable tracing to make sure
   // that tracelog still captures them.
   const int num_threads = 4;
   const int num_events = 10;
   Thread* threads[num_threads];
   PlatformThreadId thread_ids[num_threads];
   for (int i = 0; i < num_threads; i++)
     threads[i] = new Thread(StringPrintf("Thread %d", i).c_str());
 
   // Enable tracing.
@@ skipping 47 matching lines @@
                   tmp_int == static_cast<int>(base::GetCurrentProcId()));
       // If the thread name changes or the tid gets reused, the name will be
       // a comma-separated list of thread names, so look for a substring.
       EXPECT_TRUE(item->GetString("args.name", &tmp) &&
                   tmp.find(expected_name) != std::string::npos);
     }
   }
 }
 
 TEST_F(TraceEventTestFixture, ThreadNameChanges) {
-  ManualTestSetUp();
-
   BeginTrace();
 
   PlatformThread::SetName("");
   TRACE_EVENT_INSTANT0("drink", "water", TRACE_EVENT_SCOPE_THREAD);
 
   PlatformThread::SetName("cafe");
   TRACE_EVENT_INSTANT0("drink", "coffee", TRACE_EVENT_SCOPE_THREAD);
 
   PlatformThread::SetName("shop");
   // No event here, so won't appear in combined name.
@@ skipping 19 matching lines @@
 
   std::string expected_name = "cafe,pub, bar";
   std::string tmp;
   EXPECT_TRUE(item->GetString("args.name", &tmp));
   EXPECT_EQ(expected_name, tmp);
 }
 
 // Test that the disabled trace categories are included/excluded from the
 // trace output correctly.
 TEST_F(TraceEventTestFixture, DisabledCategories) {
-  ManualTestSetUp();
-
   BeginTrace();
   TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("cc"), "first",
                        TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("included", "first", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   {
     const DictionaryValue* item = NULL;
     ListValue& trace_parsed = trace_parsed_;
     EXPECT_NOT_FIND_("disabled-by-default-cc");
     EXPECT_FIND_("included");
   }
   Clear();
 
   BeginSpecificTrace("disabled-by-default-cc");
   TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("cc"), "second",
                        TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("other_included", "second", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
 
   {
     const DictionaryValue* item = NULL;
     ListValue& trace_parsed = trace_parsed_;
     EXPECT_FIND_("disabled-by-default-cc");
     EXPECT_FIND_("other_included");
   }
 }
 
-// Test trace calls made after tracing singleton shut down.
-//
-// The singleton is destroyed by our base::AtExitManager, but there can be
-// code still executing as the C++ static objects are destroyed. This test
-// forces the singleton to destroy early, and intentinally makes trace calls
-// afterwards.
-TEST_F(TraceEventTestFixture, AtExit) {
-  // Repeat this test a few times. Besides just showing robustness, it also
-  // allows us to test that events at shutdown do not appear with valid events
-  // recorded after the system is started again.
-  for (int i = 0; i < 4; i++) {
-    // Scope to contain the then destroy the TraceLog singleton.
-    {
-      base::ShadowingAtExitManager exit_manager_will_destroy_singletons;
-
-      // Setup TraceLog singleton inside this test's exit manager scope
-      // so that it will be destroyed when this scope closes.
-      ManualTestSetUp();
-
-      TRACE_EVENT_INSTANT0("all", "not recorded; system not enabled",
-                           TRACE_EVENT_SCOPE_THREAD);
-
-      BeginTrace();
-
-      TRACE_EVENT_INSTANT0("all", "is recorded 1; system has been enabled",
-                           TRACE_EVENT_SCOPE_THREAD);
-      // Trace calls that will cache pointers to categories; they're valid here
-      TraceCallsWithCachedCategoryPointersPointers(
-          "is recorded 2; system has been enabled");
-
-      EndTraceAndFlush();
-    } // scope to destroy singleton
-    ASSERT_FALSE(TraceLog::GetInstance());
-
-    // Now that singleton is destroyed, check what trace events were recorded
-    const DictionaryValue* item = NULL;
-    ListValue& trace_parsed = trace_parsed_;
-    EXPECT_FIND_("is recorded 1");
-    EXPECT_FIND_("is recorded 2");
-    EXPECT_NOT_FIND_("not recorded");
-
-    // Make additional trace event calls on the shutdown system. They should
-    // all pass cleanly, but the data not be recorded. We'll verify that next
-    // time around the loop (the only way to flush the trace buffers).
-    TRACE_EVENT_BEGIN_ETW("not recorded; system shutdown", 0, NULL);
-    TRACE_EVENT_END_ETW("not recorded; system shutdown", 0, NULL);
-    TRACE_EVENT_INSTANT_ETW("not recorded; system shutdown", 0, NULL);
-    TRACE_EVENT0("all", "not recorded; system shutdown");
-    TRACE_EVENT_INSTANT0("all", "not recorded; system shutdown",
-                         TRACE_EVENT_SCOPE_THREAD);
-    TRACE_EVENT_BEGIN0("all", "not recorded; system shutdown");
-    TRACE_EVENT_END0("all", "not recorded; system shutdown");
-
-    TRACE_EVENT0("new category 0!", "not recorded; system shutdown");
-    TRACE_EVENT_INSTANT0("new category 1!", "not recorded; system shutdown",
-                         TRACE_EVENT_SCOPE_THREAD);
-    TRACE_EVENT_BEGIN0("new category 2!", "not recorded; system shutdown");
-    TRACE_EVENT_END0("new category 3!", "not recorded; system shutdown");
-
-    // Cached categories should be safe to check, and still disable traces
-    TraceCallsWithCachedCategoryPointersPointers(
-        "not recorded; system shutdown");
-  }
-}
-
 TEST_F(TraceEventTestFixture, NormallyNoDeepCopy) {
   // Test that the TRACE_EVENT macros do not deep-copy their string. If they
   // do so it may indicate a performance regression, but more-over it would
   // make the DEEP_COPY overloads redundant.
-  ManualTestSetUp();
-
   std::string name_string("event name");
 
   BeginTrace();
   TRACE_EVENT_INSTANT0("category", name_string.c_str(),
                        TRACE_EVENT_SCOPE_THREAD);
 
   // Modify the string in place (a wholesale reassignment may leave the old
   // string intact on the heap).
   name_string[0] = '@';
 
   EndTraceAndFlush();
 
   EXPECT_FALSE(FindTraceEntry(trace_parsed_, "event name"));
   EXPECT_TRUE(FindTraceEntry(trace_parsed_, name_string.c_str()));
 }
 
 TEST_F(TraceEventTestFixture, DeepCopy) {
-  ManualTestSetUp();
-
   static const char kOriginalName1[] = "name1";
   static const char kOriginalName2[] = "name2";
   static const char kOriginalName3[] = "name3";
   std::string name1(kOriginalName1);
   std::string name2(kOriginalName2);
   std::string name3(kOriginalName3);
   std::string arg1("arg1");
   std::string arg2("arg2");
   std::string val1("val1");
   std::string val2("val2");
@@ skipping 31 matching lines @@
   std::string s;
   EXPECT_TRUE(entry3->GetString("args.arg1", &s));
   EXPECT_EQ("val1", s);
   EXPECT_TRUE(entry3->GetString("args.arg2", &s));
   EXPECT_EQ("val2", s);
 }
 
 // Test that TraceResultBuffer outputs the correct result whether it is added
 // in chunks or added all at once.
 TEST_F(TraceEventTestFixture, TraceResultBuffer) {
-  ManualTestSetUp();
-
   Clear();
 
   trace_buffer_.Start();
   trace_buffer_.AddFragment("bla1");
   trace_buffer_.AddFragment("bla2");
   trace_buffer_.AddFragment("bla3,bla4");
   trace_buffer_.Finish();
   EXPECT_STREQ(json_output_.json_output.c_str(), "[bla1,bla2,bla3,bla4]");
 
   Clear();
 
   trace_buffer_.Start();
   trace_buffer_.AddFragment("bla1,bla2,bla3,bla4");
   trace_buffer_.Finish();
   EXPECT_STREQ(json_output_.json_output.c_str(), "[bla1,bla2,bla3,bla4]");
 }
 
 // Test that trace_event parameters are not evaluated if the tracing
 // system is disabled.
 TEST_F(TraceEventTestFixture, TracingIsLazy) {
-  ManualTestSetUp();
   BeginTrace();
 
   int a = 0;
   TRACE_EVENT_INSTANT1("category", "test", TRACE_EVENT_SCOPE_THREAD, "a", a++);
   EXPECT_EQ(1, a);
 
   TraceLog::GetInstance()->SetDisabled();
 
   TRACE_EVENT_INSTANT1("category", "test", TRACE_EVENT_SCOPE_THREAD, "a", a++);
   EXPECT_EQ(1, a);
 
   EndTraceAndFlush();
 }
 
 TEST_F(TraceEventTestFixture, TraceEnableDisable) {
-  ManualTestSetUp();
-
   TraceLog* trace_log = TraceLog::GetInstance();
   CategoryFilter cf_inc_all("*");
   trace_log->SetEnabled(cf_inc_all, TraceLog::RECORD_UNTIL_FULL);
   EXPECT_TRUE(trace_log->IsEnabled());
   trace_log->SetDisabled();
   EXPECT_FALSE(trace_log->IsEnabled());
 
   trace_log->SetEnabled(cf_inc_all, TraceLog::RECORD_UNTIL_FULL);
   EXPECT_TRUE(trace_log->IsEnabled());
   const std::vector<std::string> empty;
   trace_log->SetEnabled(CategoryFilter(""), TraceLog::RECORD_UNTIL_FULL);
   EXPECT_TRUE(trace_log->IsEnabled());
   trace_log->SetDisabled();
   EXPECT_TRUE(trace_log->IsEnabled());
   trace_log->SetDisabled();
   EXPECT_FALSE(trace_log->IsEnabled());
 }
 
 TEST_F(TraceEventTestFixture, TraceCategoriesAfterNestedEnable) {
-  ManualTestSetUp();
-
   TraceLog* trace_log = TraceLog::GetInstance();
   trace_log->SetEnabled(CategoryFilter("foo,bar"), TraceLog::RECORD_UNTIL_FULL);
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo"));
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("bar"));
   EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("baz"));
   trace_log->SetEnabled(CategoryFilter("foo2"), TraceLog::RECORD_UNTIL_FULL);
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo2"));
   EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("baz"));
   // The "" becomes the default catergory set when applied.
   trace_log->SetEnabled(CategoryFilter(""), TraceLog::RECORD_UNTIL_FULL);
@@ skipping 29 matching lines @@
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("disabled-by-default-cc"));
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("disabled-by-default-gpu"));
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("bar"));
   EXPECT_STREQ("disabled-by-default-cc,disabled-by-default-gpu",
                trace_log->GetCurrentCategoryFilter().ToString().c_str());
   trace_log->SetDisabled();
   trace_log->SetDisabled();
 }
 
 TEST_F(TraceEventTestFixture, TraceOptionsParsing) {
-  ManualTestSetUp();
-
   EXPECT_EQ(TraceLog::RECORD_UNTIL_FULL,
             TraceLog::TraceOptionsFromString(std::string()));
 
   EXPECT_EQ(TraceLog::RECORD_UNTIL_FULL,
             TraceLog::TraceOptionsFromString("record-until-full"));
   EXPECT_EQ(TraceLog::RECORD_CONTINUOUSLY,
             TraceLog::TraceOptionsFromString("record-continuously"));
   EXPECT_EQ(TraceLog::RECORD_UNTIL_FULL | TraceLog::ENABLE_SAMPLING,
             TraceLog::TraceOptionsFromString("enable-sampling"));
   EXPECT_EQ(TraceLog::RECORD_CONTINUOUSLY | TraceLog::ENABLE_SAMPLING,
             TraceLog::TraceOptionsFromString(
                 "record-continuously,enable-sampling"));
 }
 
 // Not supported in split dll build. http://crbug.com/256965
 #if !defined(CHROME_SPLIT_DLL)
 TEST_F(TraceEventTestFixture, TraceSampling) {
-  ManualTestSetUp();
-
   event_watch_notification_ = 0;
   TraceLog::GetInstance()->SetEnabled(
       CategoryFilter("*"),
       TraceLog::Options(TraceLog::RECORD_UNTIL_FULL |
                         TraceLog::ENABLE_SAMPLING));
 
   WaitableEvent* sampled = new WaitableEvent(false, false);
   TraceLog::GetInstance()->InstallWaitableEventForSamplingTesting(sampled);
 
   TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(1, "cc", "Stuff");
   sampled->Wait();
   TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(1, "cc", "Things");
   sampled->Wait();
 
   EndTraceAndFlush();
 
   // Make sure we hit at least once.
   EXPECT_TRUE(FindNamePhase("Stuff", "P"));
   EXPECT_TRUE(FindNamePhase("Things", "P"));
 }
 
 TEST_F(TraceEventTestFixture, TraceSamplingScope) {
-  ManualTestSetUp();
-
   event_watch_notification_ = 0;
   TraceLog::GetInstance()->SetEnabled(
     CategoryFilter("*"),
     TraceLog::Options(TraceLog::RECORD_UNTIL_FULL |
                       TraceLog::ENABLE_SAMPLING));
 
   WaitableEvent* sampled = new WaitableEvent(false, false);
   TraceLog::GetInstance()->InstallWaitableEventForSamplingTesting(sampled);
 
   TRACE_EVENT_SCOPED_SAMPLING_STATE("AAA", "name");
@@ skipping 32 matching lines @@
 
   virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
     out->append("{\"foo\":1}");
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MyData);
 };
 
 TEST_F(TraceEventTestFixture, ConvertableTypes) {
-  ManualTestSetUp();
   TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
       TraceLog::RECORD_UNTIL_FULL);
 
   scoped_ptr<MyData> data(new MyData());
   scoped_ptr<MyData> data1(new MyData());
   scoped_ptr<MyData> data2(new MyData());
   TRACE_EVENT1("foo", "bar", "data",
                data.PassAs<base::debug::ConvertableToTraceFormat>());
   TRACE_EVENT2("foo", "baz",
                "data1", data1.PassAs<base::debug::ConvertableToTraceFormat>(),
@@ skipping 89 matching lines @@
   EXPECT_TRUE(args_dict->Get("convert", &value));
   ASSERT_TRUE(value->GetAsDictionary(&convertable_dict));
   EXPECT_TRUE(convertable_dict->GetInteger("foo", &foo_val));
   EXPECT_EQ(1, foo_val);
 }
 
 class TraceEventCallbackTest : public TraceEventTestFixture {
  public:
   virtual void SetUp() OVERRIDE {
     TraceEventTestFixture::SetUp();
-    ManualTestSetUp();
     ASSERT_EQ(NULL, s_instance);
     s_instance = this;
   }
   virtual void TearDown() OVERRIDE {
     while (TraceLog::GetInstance()->IsEnabled())
       TraceLog::GetInstance()->SetDisabled();
     ASSERT_TRUE(!!s_instance);
     s_instance = NULL;
     TraceEventTestFixture::TearDown();
   }
@@ skipping 43 matching lines @@
   TRACE_EVENT_INSTANT0("all", "a snake", TRACE_EVENT_SCOPE_GLOBAL);
   TraceLog::GetInstance()->SetEventCallback(NULL);
   ASSERT_EQ(1u, collected_events_.size());
   EXPECT_EQ("a snake", collected_events_[0]);
 }
 
 // TODO(dsinclair): Continuous Tracing unit test.
 
 // Test the category filter.
 TEST_F(TraceEventTestFixture, CategoryFilter) {
-  ManualTestSetUp();
-
   // Using the default filter.
   CategoryFilter default_cf = CategoryFilter(
       CategoryFilter::kDefaultCategoryFilterString);
   std::string category_filter_str = default_cf.ToString();
   EXPECT_STREQ("-*Debug,-*Test", category_filter_str.c_str());
   EXPECT_TRUE(default_cf.IsCategoryGroupEnabled("not-excluded-category"));
   EXPECT_FALSE(
       default_cf.IsCategoryGroupEnabled("disabled-by-default-category"));
   EXPECT_FALSE(default_cf.IsCategoryGroupEnabled("Category1,CategoryDebug"));
   EXPECT_FALSE(default_cf.IsCategoryGroupEnabled("CategoryDebug,Category1"));
@@ skipping 79 matching lines @@
   EXPECT_TRUE(CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
       "   bad_category   "));
   EXPECT_TRUE(CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
       ""));
   EXPECT_FALSE(CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
       "good_category"));
 }
 
 }  // namespace debug
 }  // namespace base