Remove special code fro calculating bucket index in linear histograms...

base/histogram.cc

 // Copyright (c) 2006-2008 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.
 
 // Histogram is an object that aggregates statistics, and can summarize them in
 // various forms, including ASCII graphical, HTML, and numerically (as a
 // vector of numbers corresponding to each of the aggregating buckets).
 // See header file for details and examples.
 
 #include "base/histogram.h"
@@ skipping 383 matching lines @@
   Histogram* render_histogram =
       StatisticsRecorder::GetHistogram(histogram_name);
 
   if (render_histogram == NULL) {
     if (histogram_type ==  EXPONENTIAL) {
       render_histogram = new Histogram(histogram_name.c_str(),
                                        declared_min,
                                        declared_max,
                                        bucket_count);
     } else if (histogram_type == LINEAR) {
-      render_histogram = reinterpret_cast<Histogram*>
-        (new LinearHistogram(histogram_name.c_str(),
-                             declared_min,
-                             declared_max,
-                             bucket_count));
+      render_histogram = new LinearHistogram(histogram_name.c_str(),
+                                             declared_min,
+                                             declared_max,
+                                             bucket_count);
     } else {
       LOG(ERROR) << "Error Deserializing Histogram Unknown histogram_type: " <<
           histogram_type;
       return false;
     }
     DCHECK(!(flags & kRendererHistogramFlag));
     render_histogram->SetFlags(flags | kRendererHistogramFlag);
   }
 
   DCHECK(declared_min == render_histogram->declared_min());
@@ skipping 158 matching lines @@
   double min = declared_min();
   double max = declared_max();
   size_t i;
   for (i = 1; i < bucket_count(); ++i) {
     double linear_range = (min * (bucket_count() -1 - i) + max * (i - 1)) /
                           (bucket_count() - 2);
     SetBucketRange(i, static_cast<int> (linear_range + 0.5));
   }
 }
 
-// Find bucket to increment for sample value.
-size_t LinearHistogram::BucketIndex(Sample value) const {
-  if (value < declared_min()) return 0;
-  if (value >= declared_max()) return bucket_count() - 1;
-  size_t index;
-  index = static_cast<size_t>(((value - declared_min()) * (bucket_count() - 2))
-                              / (declared_max() - declared_min()) + 1);
-  DCHECK(1 <= index && bucket_count() > index);
-  return index;
-}
-
 double LinearHistogram::GetBucketSize(Count current, size_t i) const {
   DCHECK(ranges(i + 1) > ranges(i));
   // Adjacent buckets with different widths would have "surprisingly" many (few)
   // samples in a histogram if we didn't normalize this way.
   double denominator = ranges(i + 1) - ranges(i);
   return current/denominator;
 }
 
 //------------------------------------------------------------------------------
 // This section provides implementation for ThreadSafeHistogram.
@@ skipping 58 matching lines @@
   return NULL != histograms_;
 }
 
 // static
 bool StatisticsRecorder::Register(Histogram* histogram) {
   if (!histograms_)
     return false;
   const std::string name = histogram->histogram_name();
   AutoLock auto_lock(*lock_);
 
-  DCHECK(histograms_->end() == histograms_->find(name)) << name << " is already"
-      "registered as a histogram.  Check for duplicate use of the name, or a "
-      "race where a static initializer could be run by several threads.";
+  if (histograms_->end() != histograms_->find(name)) {
+    // Check to be sure it is compatible.... and if not, then do a CHECK()
+    return false;  // This name is already registered.
+  }
   (*histograms_)[name] = histogram;
   return true;
 }
 
 // static
 void StatisticsRecorder::UnRegister(Histogram* histogram) {
   if (!histograms_)
     return;
   const std::string name = histogram->histogram_name();
   AutoLock auto_lock(*lock_);
@@ skipping 86 matching lines @@
       snapshot->push_back(it->second);
   }
 }
 
 // static
 StatisticsRecorder::HistogramMap* StatisticsRecorder::histograms_ = NULL;
 // static
 Lock* StatisticsRecorder::lock_ = NULL;
 // static
 bool StatisticsRecorder::dump_on_exit_ = false;