Refactor Metrics

chrome/browser/performance_monitor/performance_monitor_util.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 "chrome/browser/performance_monitor/performance_monitor_util.h"
 
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time.h"
 #include "chrome/browser/performance_monitor/database.h"
 #include "chrome/browser/performance_monitor/events.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace performance_monitor {
 namespace util {
 
-std::vector<MetricInfo> AggregateMetric(
-    const std::vector<MetricInfo>& metric_infos,
-    const base::Time& start,
-    const base::TimeDelta& resolution) {
-  std::vector<MetricInfo> results;
+std::vector<Metric> AggregateMetric(const std::vector<Metric>& metrics,
+                                    const base::Time& start,
+                                    const base::TimeDelta& resolution) {
+  std::vector<Metric> results;
   // Ignore all the points before the aggregation start.
-  std::vector<MetricInfo>::const_iterator it = metric_infos.begin();
-  for (; it != metric_infos.end() && it->time < start; ++it) { }
+  std::vector<Metric>::const_iterator it = metrics.begin();
+  for (; it != metrics.end() && it->time < start; ++it) { }
 
-  while (it != metric_infos.end()) {
+  while (it != metrics.end()) {
     // Finds the beginning of the next aggregation window.
     int64 window_offset = (it->time - start) / resolution;
     base::Time window_start = start + (window_offset * resolution);
     base::Time window_end = window_start + resolution;
     base::Time last_sample_time = window_start;
     double integrated = 0.0;
     double metric_value = 0.0;
 
-    // Aggregate the step function defined by the MetricInfos in |metric_infos|.
-    while (it != metric_infos.end() && it->time <= window_end) {
+    // Aggregate the step function defined by the Metrics in |metrics|.
+    while (it != metrics.end() && it->time <= window_end) {
       metric_value = it->value;
       integrated += metric_value * (it->time - last_sample_time).InSecondsF();
       last_sample_time = it->time;
       ++it;
     }
-    if (it != metric_infos.end())
+    if (it != metrics.end())
       metric_value = it->value;
 
     // If the window splits an area of the step function, split the aggregation
     // at the end of the window.
     integrated += metric_value * (window_end - last_sample_time).InSecondsF();
     double average = integrated / resolution.InSecondsF();
-    results.push_back(MetricInfo(window_end, average));
+    results.push_back(Metric(window_end, average));
   }
   return results;
 }
 
 bool PostTaskToDatabaseThreadAndReply(
     const tracked_objects::Location& from_here,
     const base::Closure& request,
     const base::Closure& reply) {
   base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
   base::SequencedWorkerPool::SequenceToken token =
@@ skipping 63 matching lines @@
   event.time = static_cast<double>(time.ToInternalValue());
   event.previous_version = previous_version;
   event.current_version = current_version;
   scoped_ptr<base::DictionaryValue> value = event.ToValue();
   return scoped_ptr<Event>(new Event(
       EVENT_CHROME_UPDATE, time, value.Pass()));
 }
 
 }  // namespace util
 }  // namespace performance_monitor