Refactor Metrics

chrome/browser/performance_monitor/database_unittest.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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 262 matching lines @@
   EXPECT_TRUE(events[0]->data()->Equals(new_install_event->data()));
   EXPECT_TRUE(events[1]->data()->Equals(new_uninstall_event->data()));
   events = db_->GetEvents(
       EVENT_EXTENSION_INSTALL, start_time, end_time);
   ASSERT_EQ(1u, events.size());
   EXPECT_TRUE(events[0]->data()->Equals(new_install_event->data()));
 }
 
 ////// PerformanceMonitorDatabaseMetricTests ///////////////////////////////////
 TEST_F(PerformanceMonitorDatabaseMetricTest, GetActiveMetrics) {
-  std::vector<const MetricDetails*> active_metrics =
+  std::set<MetricType> active_metrics =
     db_->GetActiveMetrics(base::Time(), clock_->GetTime());
-  std::sort(active_metrics.begin(), active_metrics.end());
 
-  std::vector<const MetricDetails*> expected_metrics;
-  expected_metrics.push_back(GetMetricDetails(METRIC_CPU_USAGE));
-  expected_metrics.push_back(GetMetricDetails(METRIC_PRIVATE_MEMORY_USAGE));
-  std::sort(expected_metrics.begin(), expected_metrics.end());
+  std::set<MetricType> expected_metrics;
+  expected_metrics.insert(METRIC_CPU_USAGE);
+  expected_metrics.insert(METRIC_PRIVATE_MEMORY_USAGE);
   EXPECT_EQ(expected_metrics, active_metrics);
 }
 
 TEST_F(PerformanceMonitorDatabaseMetricTest, GetRecentMetric) {
-  MetricInfo stat;
+  Metric stat;
   ASSERT_TRUE(db_->GetRecentStatsForActivityAndMetric(activity_,
       METRIC_PRIVATE_MEMORY_USAGE, &stat));
   EXPECT_EQ(3000000, stat.value);
 
   ASSERT_TRUE(db_->GetRecentStatsForActivityAndMetric(METRIC_CPU_USAGE, &stat));
   EXPECT_EQ(50.5, stat.value);
 
   ScopedTempDir dir;
   CHECK(dir.CreateUniqueTempDir());
   scoped_ptr<Database> db = Database::Create(dir.path());
@@ skipping 12 matching lines @@
 TEST_F(PerformanceMonitorDatabaseMetricTest, GetStateOverride) {
   std::string key("version");
   std::string value_1("1.0.0.0.0");
   std::string value_2("1.0.0.0.1");
   db_->AddStateValue(key, value_1);
   db_->AddStateValue(key, value_2);
   EXPECT_EQ(db_->GetStateValue(key), value_2);
 }
 
 TEST_F(PerformanceMonitorDatabaseMetricTest, GetStatsForActivityAndMetric) {
-  Database::MetricInfoVector stats = db_->GetStatsForActivityAndMetric(
+  std::vector<Metric> stats = db_->GetStatsForActivityAndMetric(
       activity_, METRIC_CPU_USAGE, base::Time(), clock_->GetTime());
   ASSERT_EQ(1u, stats.size());
   EXPECT_EQ(13.1, stats[0].value);
   base::Time before = clock_->GetTime();
   db_->AddMetric(activity_, METRIC_CPU_USAGE, std::string("18"));
   stats = db_->GetStatsForActivityAndMetric(activity_, METRIC_CPU_USAGE,
                                             before, clock_->GetTime());
   ASSERT_EQ(1u, stats.size());
   EXPECT_EQ(18, stats[0].value);
   stats = db_->GetStatsForActivityAndMetric(activity_, METRIC_CPU_USAGE);
   ASSERT_EQ(2u, stats.size());
   EXPECT_EQ(13.1, stats[0].value);
   EXPECT_EQ(18, stats[1].value);
   stats = db_->GetStatsForActivityAndMetric(METRIC_PRIVATE_MEMORY_USAGE);
   ASSERT_EQ(1u, stats.size());
   EXPECT_EQ(1000000, stats[0].value);
   stats = db_->GetStatsForActivityAndMetric(activity_, METRIC_CPU_USAGE,
                                             clock_->GetTime(),
                                             clock_->GetTime());
   EXPECT_TRUE(stats.empty());
 }
 
 TEST_F(PerformanceMonitorDatabaseMetricTest, GetStatsForMetricByActivity) {
   Database::MetricVectorMap stats_map = db_->GetStatsForMetricByActivity(
       METRIC_CPU_USAGE, base::Time(), clock_->GetTime());
   ASSERT_EQ(2u, stats_map.size());
-  linked_ptr<Database::MetricInfoVector> stats = stats_map[activity_];
+  linked_ptr<std::vector<Metric> > stats = stats_map[activity_];
   ASSERT_EQ(1u, stats->size());
   EXPECT_EQ(13.1, stats->at(0).value);
   stats = stats_map[kProcessChromeAggregate];
   ASSERT_EQ(1u, stats->size());
   EXPECT_EQ(50.5, stats->at(0).value);
   stats_map = db_->GetStatsForMetricByActivity(
       METRIC_CPU_USAGE, clock_->GetTime(), clock_->GetTime());
   EXPECT_EQ(0u, stats_map.size());
   base::Time before = clock_->GetTime();
   db_->AddMetric(activity_, METRIC_CPU_USAGE, std::string("18"));
   stats_map = db_->GetStatsForMetricByActivity(METRIC_CPU_USAGE, before,
                                                clock_->GetTime());
   ASSERT_EQ(1u, stats_map.size());
   stats = stats_map[activity_];
   ASSERT_EQ(1u, stats->size());
   EXPECT_EQ(18, stats->at(0).value);
 }
 
 TEST_F(PerformanceMonitorDatabaseMetricTest, GetFullRange) {
   db_->AddMetric(kProcessChromeAggregate, METRIC_CPU_USAGE, std::string("3.4"));
   db_->AddMetric(kProcessChromeAggregate, METRIC_CPU_USAGE, std::string("21"));
-  Database::MetricInfoVector stats =
+  std::vector<Metric> stats =
       db_->GetStatsForActivityAndMetric(METRIC_CPU_USAGE);
   ASSERT_EQ(3u, stats.size());
   ASSERT_EQ(50.5, stats[0].value);
   ASSERT_EQ(3.4, stats[1].value);
   ASSERT_EQ(21, stats[2].value);
 }
 
 TEST_F(PerformanceMonitorDatabaseMetricTest, GetRange) {
   base::Time start = clock_->GetTime();
   db_->AddMetric(kProcessChromeAggregate, METRIC_CPU_USAGE, std::string("3"));
   db_->AddMetric(kProcessChromeAggregate, METRIC_CPU_USAGE, std::string("9"));
   base::Time end = clock_->GetTime();
   db_->AddMetric(kProcessChromeAggregate, METRIC_CPU_USAGE, std::string("21"));
-  Database::MetricInfoVector stats =
+  std::vector<Metric> stats =
       db_->GetStatsForActivityAndMetric(METRIC_CPU_USAGE, start, end);
   ASSERT_EQ(2u, stats.size());
   ASSERT_EQ(3, stats[0].value);
   ASSERT_EQ(9, stats[1].value);
 }
 
 }  // namespace performance_monitor