Add BytesRead metric to CPM

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"
@@ skipping 32 matching lines @@
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
 using extensions::Extension;
 using performance_monitor::Event;
 
 namespace {
 
 const base::TimeDelta kMaxStartupTime = base::TimeDelta::FromMinutes(3);
+const char kSimplePage1[] = "title1.html";
+const char kSimplePage2[] = "title2.html";
 
 // 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()),
@@ skipping 66 matching lines @@
   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);
   }
 }
 
+// A wrapper for file_util::GetFileSize which takes an ASCII path relative to
+// chrome::DIR_TEST_DATA.
+bool GetFileSize(const std::string& relative_path, int64* size) {
+  FilePath test_dir;
+  PathService::Get(chrome::DIR_TEST_DATA, &test_dir);
+
+  return file_util::GetFileSize(test_dir.AppendASCII(relative_path), size);
+}
+
 }  // 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
     // 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());
 
     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,
@@ skipping 388 matching lines @@
 
   stats = GetStats(METRIC_SHARED_MEMORY_USAGE);
   ASSERT_EQ(1u, stats.size());
   EXPECT_GT(stats[0].value, 0);
 
   // Open new tabs to incur CPU usage.
   for (int i = 0; i < 10; ++i) {
     chrome::NavigateParams params(
         browser(),
         ui_test_utils::GetTestUrl(FilePath(FilePath::kCurrentDirectory),
-                                  FilePath(FILE_PATH_LITERAL("title1.html"))),
+                                  FilePath(FILE_PATH_LITERAL(kSimplePage1))),
                                   content::PAGE_TRANSITION_LINK);
     params.disposition = NEW_BACKGROUND_TAB;
     ui_test_utils::NavigateToURL(&params);
   }
   GatherStatistics();
 
   // One CPUUsage stat should exist now.
   stats = GetStats(METRIC_CPU_USAGE);
   ASSERT_EQ(1u, stats.size());
   EXPECT_GT(stats[0].value, 0);
@@ skipping 100 matching lines @@
 
   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"))));
+                                FilePath(FILE_PATH_LITERAL(kSimplePage1))));
 
   QuitBrowserAndRestore(browser(), 1);
 
   Database::MetricInfoVector 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"))));
+                                FilePath(FILE_PATH_LITERAL(kSimplePage1))));
 
   ui_test_utils::NavigateToURL(
       browser(),
       ui_test_utils::GetTestUrl(FilePath(FilePath::kCurrentDirectory),
-                                FilePath(FILE_PATH_LITERAL("title2.html"))));
+                                FilePath(FILE_PATH_LITERAL(kSimplePage1))));
 
   Database::MetricInfoVector 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());
 }
 
+IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, NetworkBytesRead) {
+  int64 page1_size = 0;
+  ASSERT_TRUE(GetFileSize(kSimplePage1, &page1_size));
+
+  int64 page2_size = 0;
+  ASSERT_TRUE(GetFileSize(kSimplePage2, &page2_size));
+
+  ASSERT_TRUE(test_server()->Start());
+
+  ui_test_utils::NavigateToURL(
+      browser(),
+      test_server()->GetURL(std::string("files/").append(kSimplePage1)));
+
+  performance_monitor()->DoTimedCollections();
+
+  Database::MetricInfoVector metrics = GetStats(METRIC_NETWORK_BYTES_READ);

[battre, 2012/08/22 08:25:24]

It this still correct? (just a question, I have not checked it myself) GetStats
flushes the queues in some order and I wonder whether this ensures that all
messages are sent and guaranteed to be executed in the right order.

[Devlin, 2012/08/22 16:22:05]

Done, added in an extra flush to be safe.

[battre, 2012/08/22 19:23:02]

Did you check whether it was needed?

[Devlin, 2012/08/22 20:34:55]

Yeah, it's needed to ensure that it will be done (until we move everything to
the blocking pool - but I have no idea if/when that will happen, or even if it's
still planned). Thanks for catching it :)

+  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.
+  ASSERT_GE(metrics[0].value, page1_size);
+
+  ui_test_utils::NavigateToURL(
+      browser(),
+      test_server()->GetURL(std::string("files/").append(kSimplePage2)));
+
+  performance_monitor()->DoTimedCollections();
+
+  metrics = GetStats(METRIC_NETWORK_BYTES_READ);
+  ASSERT_EQ(2u, metrics.size());
+  ASSERT_GE(metrics[1].value, page1_size + page2_size);
+}
+
 }  // namespace performance_monitor