Header cleanup in base....

base/histogram.cc

-// Copyright (c) 2006-2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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"
 
 #include <math.h>
 #include <string>
 
 #include "base/lock.h"
 #include "base/logging.h"
 #include "base/pickle.h"
-#include "base/string_util.h"
+#include "base/stringprintf.h"
 
 using base::TimeDelta;
 
 typedef Histogram::Count Count;
 
 scoped_refptr<Histogram> Histogram::FactoryGet(const std::string& name,
     Sample minimum, Sample maximum, size_t bucket_count, Flags flags) {
   scoped_refptr<Histogram> histogram(NULL);
 
   // Defensive code.
@@ skipping 304 matching lines @@
     double current_size = GetBucketSize(snapshot.counts(i), i);
     if (current_size > max)
       max = current_size;
   }
   return max;
 }
 
 void Histogram::WriteAsciiHeader(const SampleSet& snapshot,
                                  Count sample_count,
                                  std::string* output) const {
-  StringAppendF(output,
-                "Histogram: %s recorded %d samples",
-                histogram_name().c_str(),
-                sample_count);
+  base::StringAppendF(output,
+                      "Histogram: %s recorded %d samples",
+                      histogram_name().c_str(),
+                      sample_count);
   if (0 == sample_count) {
     DCHECK_EQ(snapshot.sum(), 0);
   } else {
     double average = static_cast<float>(snapshot.sum()) / sample_count;
     double variance = static_cast<float>(snapshot.square_sum())/sample_count
                       - average * average;
     double standard_deviation = sqrt(variance);
 
-    StringAppendF(output,
-                  ", average = %.1f, standard deviation = %.1f",
-                  average, standard_deviation);
+    base::StringAppendF(output,
+                        ", average = %.1f, standard deviation = %.1f",
+                        average, standard_deviation);
   }
   if (flags_ & ~kHexRangePrintingFlag )
-    StringAppendF(output, " (flags = 0x%x)", flags_ & ~kHexRangePrintingFlag);
+    base::StringAppendF(output, " (flags = 0x%x)",
+                        flags_ & ~kHexRangePrintingFlag);
 }
 
 void Histogram::WriteAsciiBucketContext(const int64 past,
                                         const Count current,
                                         const int64 remaining,
                                         const size_t i,
                                         std::string* output) const {
   double scaled_sum = (past + current + remaining) / 100.0;
   WriteAsciiBucketValue(current, scaled_sum, output);
   if (0 < i) {
     double percentage = past / scaled_sum;
-    StringAppendF(output, " {%3.1f%%}", percentage);
+    base::StringAppendF(output, " {%3.1f%%}", percentage);
   }
 }
 
 const std::string Histogram::GetAsciiBucketRange(size_t i) const {
   std::string result;
   if (kHexRangePrintingFlag & flags_)
-    StringAppendF(&result, "%#x", ranges(i));
+    base::StringAppendF(&result, "%#x", ranges(i));
   else
-    StringAppendF(&result, "%d", ranges(i));
+    base::StringAppendF(&result, "%d", ranges(i));
   return result;
 }
 
 void Histogram::WriteAsciiBucketValue(Count current, double scaled_sum,
                                       std::string* output) const {
-  StringAppendF(output, " (%d = %3.1f%%)", current, current/scaled_sum);
+  base::StringAppendF(output, " (%d = %3.1f%%)", current, current/scaled_sum);
 }
 
 void Histogram::WriteAsciiBucketGraph(double current_size, double max_size,
                                       std::string* output) const {
   const int k_line_length = 72;  // Maximal horizontal width of graph.
   int x_count = static_cast<int>(k_line_length * (current_size / max_size)
                                  + 0.5);
   int x_remainder = k_line_length - x_count;
 
   while (0 < x_count--)
@@ skipping 449 matching lines @@
     output->append("<br><hr><br>");
   }
   output->append("</body></html>");
 }
 
 // static
 void StatisticsRecorder::WriteGraph(const std::string& query,
                                     std::string* output) {
   if (!histograms_)
     return;
-  if (query.length())
-    StringAppendF(output, "Collections of histograms for %s\n", query.c_str());
-  else
+  if (query.length()) {
+    base::StringAppendF(output, "Collections of histograms for %s\n",
+                        query.c_str());
+  } else {
     output->append("Collections of all histograms\n");
+  }
 
   Histograms snapshot;
   GetSnapshot(query, &snapshot);
   for (Histograms::iterator it = snapshot.begin();
        it != snapshot.end();
        ++it) {
     (*it)->WriteAscii(true, "\n", output);
     output->append("\n");
   }
 }
@@ skipping 34 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;