Update from https://crrev.com/329939

base/tracked_objects.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/tracked_objects.h"
 
 #include <limits.h>
 #include <stdlib.h>
 
 #include "base/atomicops.h"
@@ skipping 150 matching lines @@
   // but that should be inconsequentially likely).  We ignore the fact that we
   // correlated our selection of a sample to the run and queue times (i.e., we
   // used them to generate random_number).
   CHECK_GT(sample_probability_count, 0);
   if (0 == (random_number % sample_probability_count)) {
     queue_duration_sample_ = queue_duration;
     run_duration_sample_ = run_duration;
   }
 }
 
-int DeathData::count() const { return count_; }
-
-int32 DeathData::run_duration_sum() const { return run_duration_sum_; }
-
-int32 DeathData::run_duration_max() const { return run_duration_max_; }
-
-int32 DeathData::run_duration_sample() const {
-  return run_duration_sample_;
-}
-
-int32 DeathData::queue_duration_sum() const {
-  return queue_duration_sum_;
-}
-
-int32 DeathData::queue_duration_max() const {
-  return queue_duration_max_;
-}
-
-int32 DeathData::queue_duration_sample() const {
-  return queue_duration_sample_;
-}
-
-const DeathDataPhaseSnapshot* DeathData::last_phase_snapshot() const {
-  return last_phase_snapshot_;
-}
-
 void DeathData::OnProfilingPhaseCompleted(int profiling_phase) {
   // Snapshotting and storing current state.
   last_phase_snapshot_ = new DeathDataPhaseSnapshot(
       profiling_phase, count_, run_duration_sum_, run_duration_max_,
       run_duration_sample_, queue_duration_sum_, queue_duration_max_,
       queue_duration_sample_, last_phase_snapshot_);
 
   // Not touching fields for which a delta can be computed by comparing with a
   // snapshot from the previous phase. Resetting other fields.  Sample values
   // will be reset upon next death recording because sample_probability_count_
@@ skipping 174 matching lines @@
 // static
 ThreadData* ThreadData::first() {
   base::AutoLock lock(*list_lock_.Pointer());
   return all_thread_data_list_head_;
 }
 
 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)
     return;  // Browser tests instigate this.
   current_thread_data = new ThreadData(suggested_name);
   tls_index_.Set(current_thread_data);
 }
 
 // static
 ThreadData* ThreadData::Get() {
@@ skipping 308 matching lines @@
     death.second.OnProfilingPhaseCompleted(profiling_phase);
   }
 }
 
 static void OptionallyInitializeAlternateTimer() {
   NowFunction* alternate_time_source = GetAlternateTimeSource();
   if (alternate_time_source)
     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.
 
   // Ensure that we don't double initialize tls.  We are called when single
   // threaded in the product, but some tests may be racy and lazy about our
   // 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
   // don't mind if there is a race, and we'd prefer not to be in a lock while
   // doing this work.
   if (kAllowAlternateTimeSourceHandling)
     OptionallyInitializeAlternateTimer();
 
   // Perform the "real" TLS initialization now, and leave it intact through
   // process termination.
   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);
   }
 
   // Incarnation counter is only significant to testing, as it otherwise will
   // never again change in this process.
   ++incarnation_counter_;
 
   // The lock is not critical for setting status_, but it doesn't hurt.  It also
   // ensures that if we have a racy initialization, that we'll bail as soon as
   // 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
 ThreadData::Status ThreadData::status() {
   return status_;
 }
 
 // static
 bool ThreadData::TrackingStatus() {
   return status_ > DEACTIVATED;
@@ skipping 33 matching lines @@
   // now.
   CHECK_GT(cleanup_count_, major_threads_shutdown_count);
 #endif
 }
 
 // static
 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());
     thread_data_list = all_thread_data_list_head_;
     all_thread_data_list_head_ = NULL;
     ++incarnation_counter_;
     // To be clean, break apart the retired worker list (though we leak them).
     while (first_retired_worker_) {
       ThreadData* worker = first_retired_worker_;
       CHECK_GT(worker->worker_thread_number_, 0);
@@ skipping 187 matching lines @@
     : process_id(base::GetCurrentProcId()) {
 #else
     : process_id(base::kNullProcessId) {
 #endif
 }
 
 ProcessDataSnapshot::~ProcessDataSnapshot() {
 }
 
 }  // namespace tracked_objects