Performance monitor stats gathering.

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 "chrome/test/base/in_process_browser_test.h"
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/performance_monitor/constants.h"
 #include "chrome/browser/performance_monitor/database.h"
 #include "chrome/browser/performance_monitor/performance_monitor.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 
 using extensions::Extension;
 using performance_monitor::Event;
 
 namespace {
+
+// Used in PerformanceMonitorBrowserTest.GatherStatistics to consume CPU cycles.
+int kSpinCount = 1000000000;
+
 // 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.
   ExtensionBasicInfo() {
   }
   explicit ExtensionBasicInfo(const Extension* extension)
       : description(extension->description()),
         id(extension->id()),
@@ skipping 121 matching lines @@
         Database::kDatabaseSequenceToken,
         FROM_HERE,
         base::Bind(&PerformanceMonitorBrowserTest::GetEventsOnBackgroundThread,
                    base::Unretained(this),
                    &events));
 
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
     return events;
   }
 
+  // Retrieves stats from the database, given |activity| and |metric|. Does the
+  // retrieval on a background thread.
+  Database::MetricInfoVector GetStatsForActivityAndMetric(
+      const std::string& activity,
+      const std::string& metric) {
+    Database::MetricInfoVector stats;
+    content::BrowserThread::PostBlockingPoolSequencedTask(
+        Database::kDatabaseSequenceToken,
+        FROM_HERE,
+        base::Bind(&PerformanceMonitorBrowserTest::
+                       GetStatsForActivityAndMetricOnBackgroundThread,
+                   base::Unretained(this),
+                   activity,
+                   metric,
+                   &stats));
+
+    content::BrowserThread::GetBlockingPool()->FlushForTesting();
+    return stats;
+  }
+
+  void GetStatsForActivityAndMetricOnBackgroundThread(
+      const std::string& activity,
+      const std::string& metric,
+      Database::MetricInfoVector* stats) {
+    *stats = performance_monitor_->database()->
+        GetStatsForActivityAndMetric(activity, metric);
+  }
+
   // A handle for inserting a state value into the database, which must be done
   // on the background thread. This is useful for mocking up a scenario in which
   // the database has prior data stored. We mock synchronicity with
   // FlushForTesting().
   void AddStateValue(const std::string& key, const std::string& value) {
     content::BrowserThread::PostBlockingPoolSequencedTask(
         Database::kDatabaseSequenceToken,
         FROM_HERE,
         base::Bind(base::IgnoreResult(&Database::AddStateValue),
                    base::Unretained(performance_monitor()->database()),
@@ skipping 204 matching lines @@
 
   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) {
+  content::BrowserThread::PostBlockingPoolSequencedTask(
+      Database::kDatabaseSequenceToken,
+      FROM_HERE,
+      base::Bind(&PerformanceMonitor::GatherStatisticsOnBackgroundThread,
+                 base::Unretained(performance_monitor())));
+
+  content::BrowserThread::GetBlockingPool()->FlushForTesting();
+
+  // Gather CPU usage. No stats should be recorded because this was the first
+  // call to GatherStatistics.
+  Database::MetricInfoVector stats = GetStatsForActivityAndMetric(
+      performance_monitor::kProcessChromeAggregate,
+      performance_monitor::kMetricCPUUsage);
+  ASSERT_EQ(0u, stats.size());
+
+  // Gather private memory usage.
+  stats = GetStatsForActivityAndMetric(
+      performance_monitor::kProcessChromeAggregate,
+      performance_monitor::kMetricPrivateMemoryUsage);
+  ASSERT_EQ(1u, stats.size());
+  EXPECT_GT(stats[0].value, 0);
+
+  // Gather shared memory usage.
+  stats = GetStatsForActivityAndMetric(
+      performance_monitor::kProcessChromeAggregate,
+      performance_monitor::kMetricSharedMemoryUsage);
+  ASSERT_EQ(1u, stats.size());
+  EXPECT_GT(stats[0].value, 0);
+
+  // TODO(mwrosen) something less barbaric?
+  // Spin for a while, so CPU usage isn't 0.
+  int i = 0;
+  for (; i < kSpinCount; ++i) {
+  }
+  ASSERT_EQ(kSpinCount, i);
+
+  content::BrowserThread::PostBlockingPoolSequencedTask(
+      Database::kDatabaseSequenceToken,
+      FROM_HERE,
+      base::Bind(&PerformanceMonitor::GatherStatisticsOnBackgroundThread,
+                 base::Unretained(performance_monitor())));
+
+  content::BrowserThread::GetBlockingPool()->FlushForTesting();
+
+  // Gather CPU usage a second time and verify a stat was recorded.
+  stats = GetStatsForActivityAndMetric(
+      performance_monitor::kProcessChromeAggregate,
+      performance_monitor::kMetricCPUUsage);
+  ASSERT_EQ(1u, stats.size());
+  EXPECT_GT(stats[0].value, 0);
+
+  // Gather private memory usage a second time and verify a second stat was
+  // recorded.
+  stats = GetStatsForActivityAndMetric(
+      performance_monitor::kProcessChromeAggregate,
+      performance_monitor::kMetricPrivateMemoryUsage);
+  ASSERT_EQ(2u, stats.size());
+  EXPECT_GT(stats[1].value, 0);
+
+  // Gather shared memory usage a second time and verify a second stat was
+  // recorded.
+  stats = GetStatsForActivityAndMetric(
+      performance_monitor::kProcessChromeAggregate,
+      performance_monitor::kMetricSharedMemoryUsage);
+  ASSERT_EQ(2u, stats.size());
+  EXPECT_GT(stats[1].value, 0);
+}
+
 #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) {
   ui_test_utils::CrashTab(chrome::GetActiveWebContents(browser()));
 
   std::vector<linked_ptr<Event> > 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,
                        DISABLED_RendererCrashEvent) {
   ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUICrashURL));
 
   std::vector<linked_ptr<Event> > events = GetEvents();
   ASSERT_EQ(1u, events.size());
 
   CheckEventType(EVENT_RENDERER_CRASH, events[0]);
 }
 
 }  // namespace performance_monitor