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 12 matching lines @@
 #include "content/public/common/page_transition_types.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/public/test/test_utils.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
 using extensions::Extension;
-using performance_monitor::Event;
+
+namespace performance_monitor {
 
 namespace {
 
 const base::TimeDelta kMaxStartupTime = base::TimeDelta::FromMinutes(3);
 
 // Helper struct to store the information of an extension; this is needed if the
 // pointer to the extension ever becomes invalid (e.g., if we uninstall the
 // extension).
 struct ExtensionBasicInfo {
   // Empty constructor for stl-container-happiness.
@@ skipping 46 matching lines @@
 void CheckEventType(int expected_event_type, const linked_ptr<Event>& event) {
   int event_type = -1;
   ASSERT_TRUE(event->data()->GetInteger("eventType", &event_type));
   ASSERT_EQ(expected_event_type, event_type);
   ASSERT_EQ(expected_event_type, event->type());
 }
 
 // Verify that we received the proper number of events, checking the type of
 // each one.
 void CheckEventTypes(const std::vector<int> expected_event_types,
-                 const std::vector<linked_ptr<Event> >& events) {
+                     const Database::EventVector& events) {
   ASSERT_EQ(expected_event_types.size(), events.size());
 
   for (size_t i = 0; i < expected_event_types.size(); ++i)
     CheckEventType(expected_event_types[i], events[i]);
 }
 
 // Check that we received the proper number of events, that each event is of the
 // proper type, and that each event recorded the proper information about the
 // extension.
 void CheckExtensionEvents(
     const std::vector<int>& expected_event_types,
-    const std::vector<linked_ptr<Event> >& events,
+    const Database::EventVector& events,
     const std::vector<ExtensionBasicInfo>& extension_infos) {
   CheckEventTypes(expected_event_types, events);
 
   for (size_t i = 0; i < expected_event_types.size(); ++i) {
     ValidateExtensionInfo(extension_infos[i], events[i]->data());
     int event_type;
     ASSERT_TRUE(events[i]->data()->GetInteger("eventType", &event_type));
     ASSERT_EQ(expected_event_types[i], event_type);
   }
 }
 
 }  // namespace
 
-namespace performance_monitor {
-
 class PerformanceMonitorBrowserTest : public ExtensionBrowserTest {
  public:
   virtual void SetUpOnMainThread() OVERRIDE {
     CHECK(db_dir_.CreateUniqueTempDir());
     performance_monitor_ = PerformanceMonitor::GetInstance();
     performance_monitor_->SetDatabasePath(db_dir_.path());
 
     // PerformanceMonitor's initialization process involves a significant
     // amount of thread-hopping between the UI thread and the background thread.
     // If we begin the tests prior to full initialization, we cannot predict
@@ skipping 14 matching lines @@
   void GatherStatistics() {
     content::BrowserThread::PostBlockingPoolSequencedTask(
         Database::kDatabaseSequenceToken,
         FROM_HERE,
         base::Bind(&PerformanceMonitor::GatherStatisticsOnBackgroundThread,
                    base::Unretained(performance_monitor())));
 
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
   }
 
-  void GetEventsOnBackgroundThread(std::vector<linked_ptr<Event> >* events) {
+  void GetEventsOnBackgroundThread(Database::EventVector* events) {
     // base::Time is potentially flaky in that there is no guarantee that it
     // won't actually decrease between successive calls. If we call GetEvents
     // and the Database uses base::Time::Now() and gets a lesser time, then it
     // will return 0 events. Thus, we use a time that is guaranteed to be in the
     // future (for at least the next couple hundred thousand years).
     *events = performance_monitor_->database()->GetEvents(
         base::Time(), base::Time::FromInternalValue(kint64max));
   }
 
   // A handle for getting the events from the database, which must be done on
   // the background thread. Since we are testing, we can mock synchronicity
   // with FlushForTesting().
-  std::vector<linked_ptr<Event> > GetEvents() {
+  Database::EventVector GetEvents() {
     // Ensure that any event insertions happen prior to getting events in order
     // to avoid race conditions.
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     content::RunAllPendingInMessageLoop();
 
-    std::vector<linked_ptr<Event> > events;
+    Database::EventVector events;
     content::BrowserThread::PostBlockingPoolSequencedTask(
         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(Database::MetricVector* 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) {
+  Database::MetricVector GetStats(MetricType type) {
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     content::RunAllPendingInMessageLoop();
 
-    Database::MetricInfoVector metrics;
+    Database::MetricVector metrics;
     content::BrowserThread::PostBlockingPoolSequencedTask(
         Database::kDatabaseSequenceToken,
         FROM_HERE,
         base::Bind(&PerformanceMonitorBrowserTest::GetStatsOnBackgroundThread,
                    base::Unretained(this),
                    &metrics,
                    type));
 
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     return metrics;
@@ skipping 152 matching lines @@
                                  .AppendASCII("extensions")
                                  .AppendASCII("simple_extension_v1");
   const Extension* extension = LoadExtension(extension_path);
 
   std::vector<ExtensionBasicInfo> extension_infos;
   extension_infos.push_back(ExtensionBasicInfo(extension));
 
   std::vector<int> expected_event_types;
   expected_event_types.push_back(EVENT_EXTENSION_INSTALL);
 
-  std::vector<linked_ptr<Event> > events = GetEvents();
+  Database::EventVector events = GetEvents();
   CheckExtensionEvents(expected_event_types, events, extension_infos);
 }
 
 // Test that PerformanceMonitor will correctly record events as an extension is
 // disabled and enabled.
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest,
                        DisableAndEnableExtensionEvent) {
   const int kNumEvents = 3;
 
   FilePath extension_path;
@@ skipping 12 matching lines @@
   //   Extension Disable
   //   Extension Enable
   for (int i = 0; i < kNumEvents; ++i)
     extension_infos.push_back(ExtensionBasicInfo(extension));
 
   std::vector<int> expected_event_types;
   expected_event_types.push_back(EVENT_EXTENSION_INSTALL);
   expected_event_types.push_back(EVENT_EXTENSION_DISABLE);
   expected_event_types.push_back(EVENT_EXTENSION_ENABLE);
 
-  std::vector<linked_ptr<Event> > events = GetEvents();
+  Database::EventVector events = GetEvents();
   CheckExtensionEvents(expected_event_types, events, extension_infos);
 }
 
 // Test that PerformanceMonitor correctly records an extension update event.
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, UpdateExtensionEvent) {
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   FilePath test_data_dir;
   PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir);
@@ skipping 40 matching lines @@
   //   Extension Update  - signal the udate to version 2
   // We push back the corresponding ExtensionBasicInfos.
   extension_infos.push_back(ExtensionBasicInfo(extension));
   extension_infos.push_back(extension_infos[1]);
 
   std::vector<int> expected_event_types;
   expected_event_types.push_back(EVENT_EXTENSION_INSTALL);
   expected_event_types.push_back(EVENT_EXTENSION_INSTALL);
   expected_event_types.push_back(EVENT_EXTENSION_UPDATE);
 
-  std::vector<linked_ptr<Event> > events = GetEvents();
+  Database::EventVector events = GetEvents();
 
   CheckExtensionEvents(expected_event_types, events, extension_infos);
 }
 
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, UninstallExtensionEvent) {
   const int kNumEvents = 2;
   FilePath extension_path;
   PathService::Get(chrome::DIR_TEST_DATA, &extension_path);
   extension_path = extension_path.AppendASCII("performance_monitor")
                                  .AppendASCII("extensions")
                                  .AppendASCII("simple_extension_v1");
   const Extension* extension = LoadExtension(extension_path);
 
   std::vector<ExtensionBasicInfo> extension_infos;
   // There will be two events, both pertaining to the same extension:
   //   Extension Install
   //   Extension Uninstall
   for (int i = 0; i < kNumEvents; ++i)
     extension_infos.push_back(ExtensionBasicInfo(extension));
 
   UninstallExtension(extension->id());
 
   std::vector<int> expected_event_types;
   expected_event_types.push_back(EVENT_EXTENSION_INSTALL);
   expected_event_types.push_back(EVENT_EXTENSION_UNINSTALL);
 
-  std::vector<linked_ptr<Event> > events = GetEvents();
+  Database::EventVector events = GetEvents();
 
   CheckExtensionEvents(expected_event_types, events, extension_infos);
 }
 
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, NewVersionEvent) {
   const char kOldVersion[] = "0.0";
 
   // The version in the database right now will be the current version of chrome
   // (gathered at initialization of PerformanceMonitor). Replace this with an
   // older version so an event is generated.
   AddStateValue(kStateChromeVersion, kOldVersion);
 
   CheckForVersionUpdate();
 
   chrome::VersionInfo version;
   ASSERT_TRUE(version.is_valid());
   std::string version_string = version.Version();
 
-  std::vector<linked_ptr<Event> > events = GetEvents();
+  Database::EventVector events = GetEvents();
   ASSERT_EQ(1u, events.size());
   ASSERT_EQ(EVENT_CHROME_UPDATE, events[0]->type());
 
   const base::DictionaryValue* value;
   ASSERT_TRUE(events[0]->data()->GetAsDictionary(&value));
 
   std::string previous_version;
   std::string current_version;
 
   ASSERT_TRUE(value->GetString("previousVersion", &previous_version));
   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);
+  Database::MetricVector 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 24 matching lines @@
 }
 
 #if !defined(OS_WIN)
 // Disabled on Windows due to a bug where Windows will return a normal exit
 // code in the testing environment, even if the process died (this is not the
 // case when hand-testing). This code can be traced to MSDN functions in
 // base::GetTerminationStatus(), so there's not much we can do.
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, KilledByOSEvent) {
   content::CrashTab(chrome::GetActiveWebContents(browser()));
 
-  std::vector<linked_ptr<Event> > events = GetEvents();
+  Database::EventVector events = GetEvents();
 
   ASSERT_EQ(1u, events.size());
   CheckEventType(EVENT_KILLED_BY_OS_CRASH, events[0]);
 }
 #endif  // !defined(OS_WIN)
 
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, RendererCrashEvent) {
   content::WindowedNotificationObserver windowed_observer(
       content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
       content::NotificationService::AllSources());
 
   ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUICrashURL));
 
   windowed_observer.Wait();
 
-  std::vector<linked_ptr<Event> > events = GetEvents();
+  Database::EventVector events = GetEvents();
   ASSERT_EQ(1u, events.size());
 
   CheckEventType(EVENT_RENDERER_CRASH, events[0]);
 }
 
 IN_PROC_BROWSER_TEST_F(PerformanceMonitorUncleanExitBrowserTest,
                        OneProfileUncleanExit) {
   // Initialize the database value (if there's no value in the database, it
   // can't determine the last active time of the profile, and doesn't insert
   // the event).
   const std::string time = "12985807272597591";
   AddStateValue(kStateProfilePrefix + first_profile_name_, time);
 
   performance_monitor()->CheckForUncleanExits();
   content::RunAllPendingInMessageLoop();
 
-  std::vector<linked_ptr<Event> > events = GetEvents();
+  Database::EventVector events = GetEvents();
 
   const size_t kNumEvents = 1;
   ASSERT_EQ(kNumEvents, events.size());
 
   CheckEventType(EVENT_UNCLEAN_EXIT, events[0]);
 
   std::string event_profile;
   ASSERT_TRUE(events[0]->data()->GetString("profileName", &event_profile));
   ASSERT_EQ(first_profile_name_, event_profile);
 }
@@ skipping 11 matching lines @@
   AddStateValue(kStateProfilePrefix + first_profile_name_, time1);
   AddStateValue(kStateProfilePrefix + second_profile_name_, time2);
 
   performance_monitor()->CheckForUncleanExits();
   content::RunAllPendingInMessageLoop();
 
   // Load the second profile, which has also exited uncleanly.
   g_browser_process->profile_manager()->GetProfile(second_profile_path);
   content::RunAllPendingInMessageLoop();
 
-  std::vector<linked_ptr<Event> > events = GetEvents();
+  Database::EventVector events = GetEvents();
 
   const size_t kNumEvents = 2;
   ASSERT_EQ(kNumEvents, events.size());
   CheckEventType(EVENT_UNCLEAN_EXIT, events[0]);
   CheckEventType(EVENT_UNCLEAN_EXIT, events[1]);
 
   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);
+  Database::MetricVector 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);
+  Database::MetricVector 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);
+  Database::MetricVector 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