Handle wrapping of task run count beyond 2^31 times.

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 <math.h>
 #include <stdlib.h>
 
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process_util.h"
 #include "base/profiler/alternate_timer.h"
 #include "base/stringprintf.h"
 #include "base/third_party/valgrind/memcheck.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/port.h"
 
 using base::TimeDelta;
 
 namespace tracked_objects {
 
 namespace {
-
 // Flag to compile out almost all of the task tracking code.
 const bool kTrackAllTaskObjects = true;
 
 // TODO(jar): Evaluate the perf impact of enabling this.  If the perf impact is
 // negligible, enable by default.
 // Flag to compile out parent-child link recording.
 const bool kTrackParentChildLinks = false;
 
 // When ThreadData is first initialized, should we start in an ACTIVE state to
 // record all of the startup-time tasks, or should we start up DEACTIVATED, so
@@ skipping 44 matching lines @@
   queue_duration_sum_ += queue_duration;
   run_duration_sum_ += run_duration;
 
   if (queue_duration_max_ < queue_duration)
     queue_duration_max_ = queue_duration;
   if (run_duration_max_ < run_duration)
     run_duration_max_ = run_duration;
 
   // Take a uniformly distributed sample over all durations ever supplied.
   // The probability that we (instead) use this new sample is 1/count_.  This
-  // results in a completely uniform selection of the sample.
-  // We ignore the fact that we correlated our selection of a sample of run
-  // and queue times.
+  // results in a completely uniform selection of the sample (at least when we
+  // don't clamp count_... 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).
+  if (count_ <= 0) {  // Handle wrapping of count_, such as in bug 138961.
+    CHECK_GE(count_ - 1, 0);  // Detect memory corruption.
+    // We'll just clamp at INT_MAX, but we should note this in the UI as such.
+    count_ = INT_MAX;
+  }
   if (0 == (random_number % 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_; }
 
@@ skipping 731 matching lines @@
       death_data(death_data),
       death_thread_name(death_thread_name) {
 }
 
 TaskSnapshot::~TaskSnapshot() {
 }
 
 //------------------------------------------------------------------------------
 // ParentChildPairSnapshot
 
-ParentChildPairSnapshot::ParentChildPairSnapshot(){
+ParentChildPairSnapshot::ParentChildPairSnapshot() {
 }
 
 ParentChildPairSnapshot::ParentChildPairSnapshot(
     const ThreadData::ParentChildPair& parent_child)
     : parent(*parent_child.first),
       child(*parent_child.second) {
 }
 
 ParentChildPairSnapshot::~ParentChildPairSnapshot() {
 }
 
 //------------------------------------------------------------------------------
 // ProcessDataSnapshot
 
 ProcessDataSnapshot::ProcessDataSnapshot()
 #if !defined(OS_NACL)
     : process_id(base::GetCurrentProcId()) {
 #else
     : process_id(0) {
 #endif
 }
 
 ProcessDataSnapshot::~ProcessDataSnapshot() {
 }
 
 }  // namespace tracked_objects