Cleanup: given that TLS slot can't fail to initialize, remove bool return values

base/trace_event/trace_event_memory.cc

 // Copyright 2013 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/trace_event/trace_event_memory.h"
 
 #include "base/debug/leak_annotations.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 52 matching lines @@
 
 // Pointer to a TraceMemoryStack per thread.
 base::ThreadLocalStorage::StaticSlot tls_trace_memory_stack = TLS_INITIALIZER;
 
 // Clean up memory pointed to by our thread-local storage.
 void DeleteStackOnThreadCleanup(void* value) {
   TraceMemoryStack* stack = static_cast<TraceMemoryStack*>(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.
 void CleanupThreadLocalStorage() {
   if (!tls_trace_memory_stack.initialized())
     return;
   TraceMemoryStack* stack =
       static_cast<TraceMemoryStack*>(tls_trace_memory_stack.Get());
   delete stack;
   tls_trace_memory_stack.Set(NULL);
@@ skipping 99 matching lines @@
       FROM_HERE,
       base::Bind(&TraceMemoryController::StopProfiling,
                  weak_factory_.GetWeakPtr()));
 }
 
 void TraceMemoryController::StartProfiling() {
   // Watch for the tracing framework sending enabling more than once.
   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);
   const int kDumpIntervalSeconds = 5;
   dump_timer_.Start(FROM_HERE,
                     TimeDelta::FromSeconds(kDumpIntervalSeconds),
                     base::Bind(&TraceMemoryController::DumpMemoryProfile,
                                weak_factory_.GetWeakPtr()));
 }
 
@@ skipping 220 matching lines @@
   if (!base::HexStringToUInt64(hex_address, &address))
     return "error";
   if (!address)
     return "null";
   // Note that this cast handles 64-bit to 32-bit conversion if necessary.
   return reinterpret_cast<const char*>(address);
 }
 
 }  // namespace trace_event
 }  // namespace base