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 191 matching lines @@
 
   base::Time start_time = clock->GetTime();
   base::Time end_time = clock->GetTime();
   std::vector<TimeRange> active_interval = db->GetActiveIntervals(start_time,
                                                                   end_time);
   EXPECT_TRUE(active_interval.empty());
 }
 
 ////// PerformanceMonitorDatabaseEventTests ////////////////////////////////////
 TEST_F(PerformanceMonitorDatabaseEventTest, GetAllEvents) {
-  std::vector<linked_ptr<Event> > events = db_->GetEvents();
+  Database::EventVector events = db_->GetEvents();
   ASSERT_EQ(4u, events.size());
   EXPECT_TRUE(events[0]->data()->Equals(install_event_1_->data()));
   EXPECT_TRUE(events[1]->data()->Equals(install_event_2_->data()));
   EXPECT_TRUE(events[2]->data()->Equals(uninstall_event_1_->data()));
   EXPECT_TRUE(events[3]->data()->Equals(uninstall_event_2_->data()));
 }
 
 TEST_F(PerformanceMonitorDatabaseEventTest, GetAllEventTypes) {
-  std::set<EventType> types = db_->GetEventTypes();
+  Database::EventTypeSet types = db_->GetEventTypes();
   ASSERT_EQ(2u, types.size());
   ASSERT_EQ(1u, types.count(EVENT_EXTENSION_INSTALL));
   ASSERT_EQ(1u, types.count(EVENT_EXTENSION_UNINSTALL));
 }
 
 TEST_F(PerformanceMonitorDatabaseEventTest, GetEventInTimeRange) {
   base::Time start_time = clock_->GetTime();
   scoped_ptr<Event> crash_event = util::CreateRendererFreezeEvent(
       clock_->GetTime(), "chrome://freeze");
   db_->AddEvent(*crash_event.get());
-  std::vector<linked_ptr<Event> > events =
-      db_->GetEvents(start_time, clock_->GetTime());
+  Database::EventVector events = db_->GetEvents(start_time, clock_->GetTime());
   ASSERT_EQ(1u, events.size());
   EXPECT_TRUE(events[0]->data()->Equals(crash_event->data()));
 }
 
 TEST_F(PerformanceMonitorDatabaseEventTest, GetInstallEvents) {
-  std::vector<linked_ptr<Event> > events =
-      db_->GetEvents(EVENT_EXTENSION_INSTALL);
+  Database::EventVector events = db_->GetEvents(EVENT_EXTENSION_INSTALL);
   ASSERT_EQ(2u, events.size());
   EXPECT_TRUE(events[0]->data()->Equals(install_event_1_->data()));
   EXPECT_TRUE(events[1]->data()->Equals(install_event_2_->data()));
 }
 
 TEST_F(PerformanceMonitorDatabaseEventTest, GetUnusedEventType) {
-  std::vector<linked_ptr<Event> > events =
-      db_->GetEvents(EVENT_EXTENSION_DISABLE);
+  Database::EventVector events = db_->GetEvents(EVENT_EXTENSION_DISABLE);
   ASSERT_TRUE(events.empty());
   events = db_->GetEvents(EVENT_EXTENSION_DISABLE, clock_->GetTime(),
                           clock_->GetTime());
   ASSERT_TRUE(events.empty());
 }
 
 TEST_F(PerformanceMonitorDatabaseEventTest, GetEventsTimeRange) {
   base::Time start_time = clock_->GetTime();
   scoped_ptr<Event> new_install_event =
       util::CreateExtensionEvent(EVENT_EXTENSION_INSTALL, clock_->GetTime(),
                                  "c", "test extension", "http://foo.com",
                                  static_cast<int>(Extension::LOAD), "0.1",
                                  "Test Test");
   scoped_ptr<Event> new_uninstall_event =
       util::CreateExtensionEvent(EVENT_EXTENSION_UNINSTALL, clock_->GetTime(),
                                  "c", "test extension", "http://foo.com",
                                  static_cast<int>(Extension::LOAD), "0.1",
                                  "Test Test");
   base::Time end_time = clock_->GetTime();
   db_->AddEvent(*new_install_event.get());
   db_->AddEvent(*new_uninstall_event.get());
-  std::vector<linked_ptr<Event> > events =
-      db_->GetEvents(start_time, end_time);
+  Database::EventVector events = db_->GetEvents(start_time, end_time);
   ASSERT_EQ(2u, events.size());
   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 =
+  Database::MetricTypeSet 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());
+  Database::MetricTypeSet 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(
+  Database::MetricVector 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<Database::MetricVector> 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 =
+  Database::MetricVector 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 =
+  Database::MetricVector 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