Refactor Metrics

chrome/browser/performance_monitor/performance_monitor_browsertest.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 "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/performance_monitor/constants.h"
 #include "chrome/browser/performance_monitor/database.h"
+#include "chrome/browser/performance_monitor/metric.h"
 #include "chrome/browser/performance_monitor/performance_monitor.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/session_service_test_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_navigator.h"
@@ skipping 172 matching lines @@
         Database::kDatabaseSequenceToken,
         FROM_HERE,
         base::Bind(&PerformanceMonitorBrowserTest::GetEventsOnBackgroundThread,
                    base::Unretained(this),
                    &events));
 
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     return events;
   }
 
-  void GetStatsOnBackgroundThread(Database::MetricInfoVector* metrics,
+  void GetStatsOnBackgroundThread(std::vector<Metric>* metrics,
                                   MetricType type) {
     *metrics = performance_monitor_->database()->GetStatsForActivityAndMetric(
         type, base::Time(), base::Time::FromInternalValue(kint64max));
   }
 
   // A handle for getting statistics from the database (see previous comments on
   // GetEvents() and GetEventsOnBackgroundThread).
-  Database::MetricInfoVector GetStats(MetricType type) {
+  std::vector<Metric> GetStats(MetricType type) {
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     content::RunAllPendingInMessageLoop();
 
-    Database::MetricInfoVector metrics;
+    std::vector<Metric> metrics;
     content::BrowserThread::PostBlockingPoolSequencedTask(
         Database::kDatabaseSequenceToken,
         FROM_HERE,
         base::Bind(&PerformanceMonitorBrowserTest::GetStatsOnBackgroundThread,
                    base::Unretained(this),
                    &metrics,
                    type));
 
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     return metrics;
@@ skipping 313 matching lines @@
   ASSERT_EQ(kOldVersion, previous_version);
   ASSERT_TRUE(value->GetString("currentVersion", &current_version));
   ASSERT_EQ(version_string, current_version);
 }
 
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, GatherStatistics) {
   GatherStatistics();
 
   // No stats should be recorded for this CPUUsage because this was the first
   // call to GatherStatistics.
-  Database::MetricInfoVector stats = GetStats(METRIC_CPU_USAGE);
+  std::vector<Metric> stats = GetStats(METRIC_CPU_USAGE);
   ASSERT_EQ(0u, stats.size());
 
   stats = GetStats(METRIC_PRIVATE_MEMORY_USAGE);
   ASSERT_EQ(1u, stats.size());
   EXPECT_GT(stats[0].value, 0);
 
   stats = GetStats(METRIC_SHARED_MEMORY_USAGE);
   ASSERT_EQ(1u, stats.size());
   EXPECT_GT(stats[0].value, 0);
 
@@ skipping 105 matching lines @@
 
   std::string event_profile;
   ASSERT_TRUE(events[0]->data()->GetString("profileName", &event_profile));
   ASSERT_EQ(first_profile_name_, event_profile);
 
   ASSERT_TRUE(events[1]->data()->GetString("profileName", &event_profile));
   ASSERT_EQ(second_profile_name_, event_profile);
 }
 
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, StartupTime) {
-  Database::MetricInfoVector metrics = GetStats(METRIC_TEST_STARTUP_TIME);
+  std::vector<Metric> metrics = GetStats(METRIC_TEST_STARTUP_TIME);
 
   ASSERT_EQ(1u, metrics.size());
   ASSERT_LT(metrics[0].value, kMaxStartupTime.ToInternalValue());
 }
 
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorSessionRestoreBrowserTest,
                        StartupWithSessionRestore) {
   ui_test_utils::NavigateToURL(
       browser(),
       ui_test_utils::GetTestUrl(FilePath(FilePath::kCurrentDirectory),
                                 FilePath(FILE_PATH_LITERAL("title1.html"))));
 
   QuitBrowserAndRestore(browser(), 1);
 
-  Database::MetricInfoVector metrics = GetStats(METRIC_TEST_STARTUP_TIME);
+  std::vector<Metric> metrics = GetStats(METRIC_TEST_STARTUP_TIME);
   ASSERT_EQ(1u, metrics.size());
   ASSERT_LT(metrics[0].value, kMaxStartupTime.ToInternalValue());
 
   metrics = GetStats(METRIC_SESSION_RESTORE_TIME);
   ASSERT_EQ(1u, metrics.size());
   ASSERT_LT(metrics[0].value, kMaxStartupTime.ToInternalValue());
 }
 
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, PageLoadTime) {
   const base::TimeDelta kMaxLoadTime = base::TimeDelta::FromSeconds(30);
 
   ui_test_utils::NavigateToURL(
       browser(),
       ui_test_utils::GetTestUrl(FilePath(FilePath::kCurrentDirectory),
                                 FilePath(FILE_PATH_LITERAL("title1.html"))));
 
   ui_test_utils::NavigateToURL(
       browser(),
       ui_test_utils::GetTestUrl(FilePath(FilePath::kCurrentDirectory),
                                 FilePath(FILE_PATH_LITERAL("title2.html"))));
 
-  Database::MetricInfoVector metrics = GetStats(METRIC_PAGE_LOAD_TIME);
+  std::vector<Metric> metrics = GetStats(METRIC_PAGE_LOAD_TIME);
 
   ASSERT_EQ(2u, metrics.size());
   ASSERT_LT(metrics[0].value, kMaxLoadTime.ToInternalValue());
   ASSERT_LT(metrics[1].value, kMaxLoadTime.ToInternalValue());
 }
 
 }  // namespace performance_monitor