Cleanup base profiler initialization code.

Given that TLS slot can't fail to initialize, remove bool return values
from initialization functions that actually can't fail.

Based off of vadimt@'s CL here:
https://codereview.chromium.org/1124493002/

BUG=456354

Review URL: https://codereview.chromium.org/1128653002

Cr-Commit-Position: refs/heads/master@{#328774}

8 files changed, 47 insertions, 149 deletions

diff --git a/base/profiler/tracked_time_unittest.cc b/base/profiler/tracked_time_unittest.cc
index 4806a90..c105688 100644
--- a/base/profiler/tracked_time_unittest.cc
+++ b/base/profiler/tracked_time_unittest.cc
@@ -70,16 +70,14 @@ TEST(TrackedTimeTest, TrackedTimerVsTimeTicks) {
 TEST(TrackedTimeTest, TrackedTimerDisabled) {
   // Check to be sure disabling the collection of data induces a null time
   // (which we know will return much faster).
-  if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED))
-    return;
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED);
   // Since we disabled tracking, we should get a null response.
   TrackedTime track_now = ThreadData::Now();
   EXPECT_TRUE(track_now.is_null());
 }
 
 TEST(TrackedTimeTest, TrackedTimerEnabled) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE))
-    return;
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
   // Make sure that when we enable tracking, we get a real timer result.
 
   // First get a 64 bit timer (which should not be null).
diff --git a/base/threading/thread_local_android.cc b/base/threading/thread_local_android.cc
index c890237..813dd78 100644
--- a/base/threading/thread_local_android.cc
+++ b/base/threading/thread_local_android.cc
@@ -4,15 +4,12 @@
 
 #include "base/threading/thread_local.h"
 
-#include "base/logging.h"
-
 namespace base {
 namespace internal {
 
 // static
 void ThreadLocalPlatform::AllocateSlot(SlotType* slot) {
-  bool succeed = slot->Initialize(NULL);
-  CHECK(succeed);
+  slot->Initialize(nullptr);
 }
 
 // static
diff --git a/base/threading/thread_local_storage.cc b/base/threading/thread_local_storage.cc
index 54928ed..0bb396c 100644
--- a/base/threading/thread_local_storage.cc
+++ b/base/threading/thread_local_storage.cc
@@ -197,7 +197,7 @@ ThreadLocalStorage::Slot::Slot(TLSDestructorFunc destructor) {
   Initialize(destructor);
 }
 
-bool ThreadLocalStorage::StaticSlot::Initialize(TLSDestructorFunc destructor) {
+void ThreadLocalStorage::StaticSlot::Initialize(TLSDestructorFunc destructor) {
   PlatformThreadLocalStorage::TLSKey key =
       base::subtle::NoBarrier_Load(&g_native_tls_key);
   if (key == PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES ||
@@ -212,7 +212,6 @@ bool ThreadLocalStorage::StaticSlot::Initialize(TLSDestructorFunc destructor) {
   // Setup our destructor.
   g_tls_destructors[slot_] = destructor;
   initialized_ = true;
-  return true;
 }
 
 void ThreadLocalStorage::StaticSlot::Free() {
diff --git a/base/threading/thread_local_storage.h b/base/threading/thread_local_storage.h
index ea41b34..50f8868 100644
--- a/base/threading/thread_local_storage.h
+++ b/base/threading/thread_local_storage.h
@@ -98,8 +98,7 @@ class BASE_EXPORT ThreadLocalStorage {
     // Set up the TLS slot.  Called by the constructor.
     // 'destructor' is a pointer to a function to perform per-thread cleanup of
     // this object.  If set to NULL, no cleanup is done for this TLS slot.
-    // Returns false on error.
-    bool Initialize(TLSDestructorFunc destructor);
+    void Initialize(TLSDestructorFunc destructor);
 
     // Free a previously allocated TLS 'slot'.
     // If a destructor was set for this slot, removes
diff --git a/base/trace_event/trace_event_memory.cc b/base/trace_event/trace_event_memory.cc
index ab8ba0d3..8959589 100644
--- a/base/trace_event/trace_event_memory.cc
+++ b/base/trace_event/trace_event_memory.cc
@@ -71,13 +71,12 @@ void DeleteStackOnThreadCleanup(void* value) {
   delete stack;
 }
 
-// Initializes the thread-local TraceMemoryStack pointer. Returns true on
-// success or if it is already initialized.
-bool InitThreadLocalStorage() {
+// Initializes the thread-local TraceMemoryStack pointer.
+void InitThreadLocalStorage() {
   if (tls_trace_memory_stack.initialized())
-    return true;
-  // Initialize the thread-local storage key, returning true on success.
-  return tls_trace_memory_stack.Initialize(&DeleteStackOnThreadCleanup);
+    return;
+  // Initialize the thread-local storage key.
+  tls_trace_memory_stack.Initialize(&DeleteStackOnThreadCleanup);
 }
 
 // Clean up thread-local-storage in the main thread.
@@ -195,8 +194,7 @@ void TraceMemoryController::StartProfiling() {
   if (dump_timer_.IsRunning())
     return;
   DVLOG(1) << "Starting trace memory";
-  if (!InitThreadLocalStorage())
-    return;
+  InitThreadLocalStorage();
   ScopedTraceMemory::set_enabled(true);
   // Call ::HeapProfilerWithPseudoStackStart().
   heap_profiler_start_function_(&GetPseudoStack);
diff --git a/base/tracked_objects.cc b/base/tracked_objects.cc
index f6ea4df..9db05c0 100644
--- a/base/tracked_objects.cc
+++ b/base/tracked_objects.cc
@@ -362,8 +362,7 @@ ThreadData* ThreadData::next() const { return next_; }
 
 // static
 void ThreadData::InitializeThreadContext(const std::string& suggested_name) {
-  if (!Initialize())  // Always initialize if needed.
-    return;
+  Initialize();
   ThreadData* current_thread_data =
       reinterpret_cast<ThreadData*>(tls_index_.Get());
   if (current_thread_data)
@@ -692,9 +691,9 @@ static void OptionallyInitializeAlternateTimer() {
     ThreadData::SetAlternateTimeSource(alternate_time_source);
 }
 
-bool ThreadData::Initialize() {
+void ThreadData::Initialize() {
   if (status_ >= DEACTIVATED)
-    return true;  // Someone else did the initialization.
+    return;  // Someone else did the initialization.
   // Due to racy lazy initialization in tests, we'll need to recheck status_
   // after we acquire the lock.
 
@@ -703,7 +702,7 @@ bool ThreadData::Initialize() {
   // initialization.
   base::AutoLock lock(*list_lock_.Pointer());
   if (status_ >= DEACTIVATED)
-    return true;  // Someone raced in here and beat us.
+    return;  // Someone raced in here and beat us.
 
   // Put an alternate timer in place if the environment calls for it, such as
   // for tracking TCMalloc allocations.  This insertion is idempotent, so we
@@ -717,8 +716,7 @@ bool ThreadData::Initialize() {
   if (!tls_index_.initialized()) {  // Testing may have initialized this.
     DCHECK_EQ(status_, UNINITIALIZED);
     tls_index_.Initialize(&ThreadData::OnThreadTermination);
-    if (!tls_index_.initialized())
-      return false;
+    DCHECK(tls_index_.initialized());
   } else {
     // TLS was initialzed for us earlier.
     DCHECK_EQ(status_, DORMANT_DURING_TESTS);
@@ -733,21 +731,18 @@ bool ThreadData::Initialize() {
   // we get the lock earlier in this method.
   status_ = kInitialStartupState;
   DCHECK(status_ != UNINITIALIZED);
-  return true;
 }
 
 // static
-bool ThreadData::InitializeAndSetTrackingStatus(Status status) {
+void ThreadData::InitializeAndSetTrackingStatus(Status status) {
   DCHECK_GE(status, DEACTIVATED);
   DCHECK_LE(status, PROFILING_ACTIVE);
 
-  if (!Initialize())  // No-op if already initialized.
-    return false;  // Not compiled in.
+  Initialize();  // No-op if already initialized.
 
   if (status > DEACTIVATED)
     status = PROFILING_ACTIVE;
   status_ = status;
-  return true;
 }
 
 // static
@@ -801,8 +796,8 @@ 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(DEACTIVATED))
-    return;
+  InitializeAndSetTrackingStatus(DEACTIVATED);
+
   ThreadData* thread_data_list;
   {
     base::AutoLock lock(*list_lock_.Pointer());
diff --git a/base/tracked_objects.h b/base/tracked_objects.h
index efa8859..8f83794 100644
--- a/base/tracked_objects.h
+++ b/base/tracked_objects.h
@@ -499,14 +499,13 @@ class BASE_EXPORT ThreadData {
   const std::string& thread_name() const { return thread_name_; }
 
   // Initializes all statics if needed (this initialization call should be made
-  // while we are single threaded).  Returns false if unable to initialize.
-  static bool Initialize();
+  // while we are single threaded).
+  static void Initialize();
 
   // Sets internal status_.
   // If |status| is false, then status_ is set to DEACTIVATED.
   // If |status| is true, then status_ is set to PROFILING_ACTIVE.
-  // If it fails to initialize the TLS slot, this function will return false.
-  static bool InitializeAndSetTrackingStatus(Status status);
+  static void InitializeAndSetTrackingStatus(Status status);
 
   static Status status();
 
diff --git a/base/tracked_objects_unittest.cc b/base/tracked_objects_unittest.cc
index 3537e54..cdbf9ac 100644
--- a/base/tracked_objects_unittest.cc
+++ b/base/tracked_objects_unittest.cc
@@ -119,11 +119,7 @@ class TrackedObjectsTest : public testing::Test {
 unsigned int TrackedObjectsTest::test_time_;
 
 TEST_F(TrackedObjectsTest, TaskStopwatchNoStartStop) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   // Check that creating and destroying a stopwatch without starting it doesn't
   // crash.
@@ -132,11 +128,7 @@ TEST_F(TrackedObjectsTest, TaskStopwatchNoStartStop) {
 
 TEST_F(TrackedObjectsTest, MinimalStartupShutdown) {
   // Minimal test doesn't even create any tasks.
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
   ThreadData* data = ThreadData::Get();
@@ -154,8 +146,7 @@ TEST_F(TrackedObjectsTest, MinimalStartupShutdown) {
   Reset();
 
   // Do it again, just to be sure we reset state completely.
-  EXPECT_TRUE(
-      ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE));
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
   EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
   data = ThreadData::Get();
   EXPECT_TRUE(ThreadData::first());  // Now class was constructed.
@@ -170,11 +161,7 @@ TEST_F(TrackedObjectsTest, MinimalStartupShutdown) {
 }
 
 TEST_F(TrackedObjectsTest, TinyStartupShutdown) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   // Instigate tracking on a single tracked object, on our thread.
   const char kFunction[] = "TinyStartupShutdown";
@@ -250,11 +237,7 @@ TEST_F(TrackedObjectsTest, TinyStartupShutdown) {
 }
 
 TEST_F(TrackedObjectsTest, DeathDataTestRecordDeath) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   scoped_ptr<DeathData> data(new DeathData());
   ASSERT_NE(data, reinterpret_cast<DeathData*>(NULL));
@@ -293,11 +276,7 @@ TEST_F(TrackedObjectsTest, DeathDataTestRecordDeath) {
 }
 
 TEST_F(TrackedObjectsTest, DeathDataTest2Phases) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   scoped_ptr<DeathData> data(new DeathData());
   ASSERT_NE(data, reinterpret_cast<DeathData*>(NULL));
@@ -362,11 +341,7 @@ TEST_F(TrackedObjectsTest, DeathDataTest2Phases) {
 }
 
 TEST_F(TrackedObjectsTest, Delta) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   DeathDataSnapshot snapshot;
   snapshot.count = 10;
@@ -398,10 +373,7 @@ TEST_F(TrackedObjectsTest, Delta) {
 
 TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToSnapshotWorkerThread) {
   // Start in the deactivated state.
-  if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED);
 
   const char kFunction[] = "DeactivatedBirthOnlyToSnapshotWorkerThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
@@ -423,10 +395,7 @@ TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToSnapshotWorkerThread) {
 
 TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToSnapshotMainThread) {
   // Start in the deactivated state.
-  if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED);
 
   const char kFunction[] = "DeactivatedBirthOnlyToSnapshotMainThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
@@ -447,11 +416,7 @@ TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToSnapshotMainThread) {
 }
 
 TEST_F(TrackedObjectsTest, BirthOnlyToSnapshotWorkerThread) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "BirthOnlyToSnapshotWorkerThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
@@ -464,11 +429,7 @@ TEST_F(TrackedObjectsTest, BirthOnlyToSnapshotWorkerThread) {
 }
 
 TEST_F(TrackedObjectsTest, BirthOnlyToSnapshotMainThread) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "BirthOnlyToSnapshotMainThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
@@ -481,11 +442,7 @@ TEST_F(TrackedObjectsTest, BirthOnlyToSnapshotMainThread) {
 }
 
 TEST_F(TrackedObjectsTest, LifeCycleToSnapshotMainThread) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "LifeCycleToSnapshotMainThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
@@ -514,11 +471,7 @@ TEST_F(TrackedObjectsTest, LifeCycleToSnapshotMainThread) {
 }
 
 TEST_F(TrackedObjectsTest, TwoPhases) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "TwoPhases";
   Location location(kFunction, kFile, kLineNumber, NULL);
@@ -617,11 +570,7 @@ TEST_F(TrackedObjectsTest, TwoPhases) {
 }
 
 TEST_F(TrackedObjectsTest, ThreePhases) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "ThreePhases";
   Location location(kFunction, kFile, kLineNumber, NULL);
@@ -762,11 +711,7 @@ TEST_F(TrackedObjectsTest, ThreePhases) {
 }
 
 TEST_F(TrackedObjectsTest, TwoPhasesSecondEmpty) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "TwoPhasesSecondEmpty";
   Location location(kFunction, kFile, kLineNumber, NULL);
@@ -829,11 +774,7 @@ TEST_F(TrackedObjectsTest, TwoPhasesSecondEmpty) {
 }
 
 TEST_F(TrackedObjectsTest, TwoPhasesFirstEmpty) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   ThreadData::OnProfilingPhaseCompleted(0);
 
@@ -894,11 +835,7 @@ TEST_F(TrackedObjectsTest, TwoPhasesFirstEmpty) {
 // our tallied births are matched by tallied deaths (except for when the
 // task is still running, or is queued).
 TEST_F(TrackedObjectsTest, LifeCycleMidDeactivatedToSnapshotMainThread) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "LifeCycleMidDeactivatedToSnapshotMainThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
@@ -911,8 +848,7 @@ TEST_F(TrackedObjectsTest, LifeCycleMidDeactivatedToSnapshotMainThread) {
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   // Turn off tracking now that we have births.
-  EXPECT_TRUE(
-      ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED));
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED);
 
   const unsigned int kStartOfRun = 5;
   const unsigned int kEndOfRun = 7;
@@ -934,10 +870,7 @@ TEST_F(TrackedObjectsTest, LifeCycleMidDeactivatedToSnapshotMainThread) {
 // the birth nor the death will be recorded.
 TEST_F(TrackedObjectsTest, LifeCyclePreDeactivatedToSnapshotMainThread) {
   // Start in the deactivated state.
-  if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED);
 
   const char kFunction[] = "LifeCyclePreDeactivatedToSnapshotMainThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
@@ -974,11 +907,7 @@ TEST_F(TrackedObjectsTest, LifeCyclePreDeactivatedToSnapshotMainThread) {
 }
 
 TEST_F(TrackedObjectsTest, TwoLives) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "TwoLives";
   Location location(kFunction, kFile, kLineNumber, NULL);
@@ -1018,11 +947,7 @@ TEST_F(TrackedObjectsTest, TwoLives) {
 }
 
 TEST_F(TrackedObjectsTest, DifferentLives) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext(kMainThreadName);
@@ -1094,11 +1019,7 @@ TEST_F(TrackedObjectsTest, DifferentLives) {
 }
 
 TEST_F(TrackedObjectsTest, TaskWithNestedExclusion) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "TaskWithNestedExclusion";
   Location location(kFunction, kFile, kLineNumber, NULL);
@@ -1132,11 +1053,7 @@ TEST_F(TrackedObjectsTest, TaskWithNestedExclusion) {
 }
 
 TEST_F(TrackedObjectsTest, TaskWith2NestedExclusions) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "TaskWith2NestedExclusions";
   Location location(kFunction, kFile, kLineNumber, NULL);
@@ -1176,11 +1093,7 @@ TEST_F(TrackedObjectsTest, TaskWith2NestedExclusions) {
 }
 
 TEST_F(TrackedObjectsTest, TaskWithNestedExclusionWithNestedTask) {
-  if (!ThreadData::InitializeAndSetTrackingStatus(
-          ThreadData::PROFILING_ACTIVE)) {
-    // Don't run the test if task tracking is not compiled in.
-    return;
-  }
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   const char kFunction[] = "TaskWithNestedExclusionWithNestedTask";
   Location location(kFunction, kFile, kLineNumber, NULL);