PerformanceMonitor: UMA alert for high browser CPU usage.

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/files/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 143 matching lines @@
 
     // 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
     // the behavior or mock synchronicity as we must. Wait for initialization
     // to complete fully before proceeding with the test.
     content::WindowedNotificationObserver windowed_observer(
         chrome::NOTIFICATION_PERFORMANCE_MONITOR_INITIALIZED,
         content::NotificationService::AllSources());
 
+    // We stop the timer in charge of doing timed collections so that we can
+    // enforce when, and how many times, we do these collections.
+    performance_monitor_->disable_timer_autostart_ = true;
+    // Force metrics to be stored, regardless of switches used.
+    performance_monitor_->database_logging_enabled_ = true;
     performance_monitor_->Start();
 
     windowed_observer.Wait();
-
-    // We stop the timer in charge of doing timed collections so that we can
-    // enforce when, and how many times, we do these collections.
-    performance_monitor_->timer_.Stop();
   }
 
   // A handle for gathering statistics from the database, which must be done on
   // the background thread. Since we are testing, we can mock synchronicity with
   // FlushForTesting().
   void GatherStatistics() {
-    content::BrowserThread::PostBlockingPoolSequencedTask(
-        Database::kDatabaseSequenceToken,
-        FROM_HERE,
-        base::Bind(&PerformanceMonitor::GatherStatisticsOnBackgroundThread,
-                   base::Unretained(performance_monitor())));
+    performance_monitor_->next_collection_time_ = base::Time::Now();
+    performance_monitor_->GatherMetricsMapOnUIThread();
 
+    RunAllPendingInMessageLoop(content::BrowserThread::IO);
     content::BrowserThread::GetBlockingPool()->FlushForTesting();
   }
 
   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(
@@ skipping 572 matching lines @@
   int64 page2_size = 0;
   ASSERT_TRUE(file_util::GetFileSize(test_dir.AppendASCII("title2.html"),
                                      &page2_size));
 
   ASSERT_TRUE(test_server()->Start());
 
   ui_test_utils::NavigateToURL(
       browser(),
       test_server()->GetURL(std::string("files/").append("title1.html")));
 
-  performance_monitor()->DoTimedCollections();
-
-  // Since network bytes are read and set on the IO thread, we must flush this
-  // additional thread to be sure that all messages are run.
-  RunAllPendingInMessageLoop(content::BrowserThread::IO);
+  GatherStatistics();
 
   Database::MetricVector metrics = GetStats(METRIC_NETWORK_BYTES_READ);
   ASSERT_EQ(1u, metrics.size());
   // Since these pages are read over the "network" (actually the test_server),
   // some extraneous information is carried along, and the best check we can do
   // is for greater than or equal to.
   EXPECT_GE(metrics[0].value, page1_size);
 
   ui_test_utils::NavigateToURL(
       browser(),
       test_server()->GetURL(std::string("files/").append("title2.html")));
 
-  performance_monitor()->DoTimedCollections();
+  GatherStatistics();
 
   metrics = GetStats(METRIC_NETWORK_BYTES_READ);
   ASSERT_EQ(2u, metrics.size());
   EXPECT_GE(metrics[1].value, page1_size + page2_size);
 }
 
 }  // namespace performance_monitor