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 86 matching lines @@
     const char* name = PlatformThread::GetName();
     old_thread_name_ = name ? strdup(name) : NULL;
     notifications_received_ = 0;
   }
   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(
@@ skipping 1379 matching lines @@
   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.

[scheib, 2013/07/08 22:58:57]

I was initially hesitant to remove this test- but in conversation agree that
with TraceLog being a normal singleton there is no need to test for different
behavior of calls made after the singleton is removed. New categories will
perform a null check after TraceLog::GetInstance in GetCategoryGroupEnabled.
Existing categories will be looked up and be false.

however, since we're removing this we can also change ManualTestSetUp to just
SetUp and remove calls to it in this file.

[jam, 2013/07/08 23:03:10]

Done.

-//
-// 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(),
@@ skipping 538 matching lines @@
   EXPECT_TRUE(CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
       "   bad_category   "));
   EXPECT_TRUE(CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
       ""));
   EXPECT_FALSE(CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
       "good_category"));
 }
 
 }  // namespace debug
 }  // namespace base