Minor cleanup preparing for recording parent-child data

base/tracked_objects.cc

 // Copyright (c) 2011 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 "base/format_macros.h"
 #include "base/message_loop.h"
@@ skipping 25 matching lines @@
 
 DeathData::DeathData() {
   Clear();
 }
 
 DeathData::DeathData(int count) {
   Clear();
   count_ = count;
 }
 
-// TODO(jar): I need to see if this macro to optimize branching is worth it.
+// TODO(jar): I need to see if this macro to optimize branching is worth using.
 //
 // This macro has no branching, so it is surely fast, and is equivalent to:
 //             if (assign_it)
 //               target = source;
 // We use a macro rather than a template to force this to inline.
 // Related code for calculating max is discussed on the web.
 #define CONDITIONAL_ASSIGN(assign_it, target, source) \
     ((target) ^= ((target) ^ (source)) & -static_cast<DurationInt>(assign_it))
 
 void DeathData::RecordDeath(const DurationInt queue_duration,
                             const DurationInt run_duration,
                             int32 random_number) {
+  ++count_;
   queue_duration_sum_ += queue_duration;
   run_duration_sum_ += run_duration;
-  ++count_;
+
+  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.
-  bool take_sample = 0 == (random_number % count_);
-  CONDITIONAL_ASSIGN(take_sample, queue_duration_sample_, queue_duration);
-  CONDITIONAL_ASSIGN(take_sample, run_duration_sample_, run_duration);
-
-  CONDITIONAL_ASSIGN(queue_duration_max_ < queue_duration, queue_duration_max_,
-                     queue_duration);
-  CONDITIONAL_ASSIGN(run_duration_max_ < run_duration, run_duration_max_,
-                     run_duration);
-  // Ensure we got the macros right.
-  DCHECK_GE(queue_duration_max_, queue_duration);
-  DCHECK_GE(run_duration_max_, run_duration);
-  DCHECK(!take_sample || run_duration_sample_ == run_duration);
-  DCHECK(!take_sample || queue_duration_sample_ == queue_duration);
+  if (0 == (random_number % count_)) {
+    queue_duration_sample_ = queue_duration;
+    run_duration_sample_ = run_duration;
+  }
 }
 
 int DeathData::count() const { return count_; }
 
 DurationInt DeathData::run_duration_sum() const { return run_duration_sum_; }
 
 DurationInt DeathData::run_duration_max() const { return run_duration_max_; }
 
 DurationInt DeathData::run_duration_sample() const {
   return run_duration_sample_;
@@ skipping 651 matching lines @@
 
 base::ListValue* DataCollector::ToValue() const {
   base::ListValue* list = new base::ListValue;
   for (size_t i = 0; i < collection_.size(); ++i) {
     list->Append(collection_[i].ToValue());
   }
   return list;
 }
 
 }  // namespace tracked_objects