Add memory stats for linux page cycler. On linux, we collect

chrome/test/page_cycler/page_cycler_test.cc

 // Copyright (c) 2006-2009 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/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/automation/window_proxy.h"
 #include "chrome/test/chrome_process_util.h"
 #include "chrome/test/ui/ui_test.h"
-#include "chrome/test/perf/mem_usage.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 
 #ifndef NDEBUG
 #define TEST_ITERATIONS "2"
 #else
 #define TEST_ITERATIONS "10"
 #endif
 
 // URL at which data files may be found for HTTP tests.  The document root of
@@ skipping 47 matching lines @@
 
     std::string cookie;
     ASSERT_TRUE(tab->GetCookieByName(test_url, "__pc_pages", &cookie));
     pages->assign(UTF8ToWide(cookie));
     ASSERT_FALSE(pages->empty());
     ASSERT_TRUE(tab->GetCookieByName(test_url, "__pc_timings", &cookie));
     timings->assign(cookie);
     ASSERT_FALSE(timings->empty());
   }
 
-#if defined(OS_WIN)
-  // TODO(port): Port chrome_process_util and remove windowsisms.
   void PrintIOPerfInfo(const char* test_name) {
     FilePath data_dir;
     PathService::Get(chrome::DIR_USER_DATA, &data_dir);
     int browser_process_pid = ChromeBrowserProcessId(data_dir);
     ChromeProcessList chrome_processes(GetRunningChromeProcesses(data_dir));
 
     ChromeProcessList::const_iterator it;
     for (it = chrome_processes.begin(); it != chrome_processes.end(); ++it) {
       base::ProcessHandle process_handle;
       if (!base::OpenProcessHandle(*it, &process_handle)) {
         NOTREACHED();
       }
 
       scoped_ptr<base::ProcessMetrics> process_metrics;
-      IO_COUNTERS io_counters;
       process_metrics.reset(
           base::ProcessMetrics::CreateProcessMetrics(process_handle));
-      ZeroMemory(&io_counters, sizeof(io_counters));
+      IoCounters io_counters;
+      memset(&io_counters, 0, sizeof(io_counters));
 
       if (process_metrics.get()->GetIOCounters(&io_counters)) {
         // Print out IO performance.  We assume that the values can be
         // converted to size_t (they're reported as ULONGLONG, 64-bit numbers).
         std::string chrome_name = (*it == browser_process_pid) ? "_b" : "_r";
 
         PrintResult("read_op", chrome_name,
                     "r_op" + chrome_name + test_name,
                     static_cast<size_t>(io_counters.ReadOperationCount), "",
                     false /* not important */);
@@ skipping 39 matching lines @@
   }
 
   void PrintMemoryUsageInfo(const char* test_name) {
     FilePath data_dir;
     PathService::Get(chrome::DIR_USER_DATA, &data_dir);
     int browser_process_pid = ChromeBrowserProcessId(data_dir);
     ChromeProcessList chrome_processes(GetRunningChromeProcesses(data_dir));
 
     ChromeProcessList::const_iterator it;
     for (it = chrome_processes.begin(); it != chrome_processes.end(); ++it) {
-      size_t peak_virtual_size;
-      size_t current_virtual_size;
-      size_t peak_working_set_size;
-      size_t current_working_set_size;
-      if (GetMemoryInfo(*it, &peak_virtual_size, &current_virtual_size,
-                        &peak_working_set_size, &current_working_set_size)) {
-        std::string chrome_name = (*it == browser_process_pid) ? "_b" : "_r";
+      base::ProcessHandle process_handle;
+      if (!base::OpenProcessHandle(*it, &process_handle)) {
+        NOTREACHED();
+      }
 
-        std::string trace_name(test_name);
-        PrintResult("vm_peak", chrome_name,
-                    "vm_pk" + chrome_name + trace_name,
-                    peak_virtual_size, "bytes",
-                    true /* important */);
-        PrintResult("vm_final", chrome_name,
-                    "vm_f" + chrome_name + trace_name,
-                    current_virtual_size, "bytes",
-                    false /* not important */);
-        PrintResult("ws_peak", chrome_name,
-                    "ws_pk" + chrome_name + trace_name,
-                    peak_working_set_size, "bytes",
-                    true /* important */);
-        PrintResult("ws_final", chrome_name,
-                    "ws_pk" + chrome_name + trace_name,
-                    current_working_set_size, "bytes",
-                    false /* not important */);
-      }
+      scoped_ptr<base::ProcessMetrics> process_metrics;
+      process_metrics.reset(
+          base::ProcessMetrics::CreateProcessMetrics(process_handle));
+
+      std::string chrome_name = (*it == browser_process_pid) ? "_b" : "_r";
+
+      std::string trace_name(test_name);
+#if defined(OS_WIN)
+      PrintResult("vm_peak", chrome_name,
+                  "vm_pk" + chrome_name + trace_name,
+                  process_metrics->GetPeakPagefileUsage(), "bytes",
+                  true /* important */);
+      PrintResult("vm_final", chrome_name,
+                  "vm_f" + chrome_name + trace_name,
+                  process_metrics->GetPagefileUsage(), "bytes",
+                  false /* not important */);
+      PrintResult("ws_peak", chrome_name,
+                  "ws_pk" + chrome_name + trace_name,
+                  process_metrics->GetPeakWorkingSetSize(), "bytes",
+                  true /* important */);
+      PrintResult("ws_final", chrome_name,
+                  "ws_f" + chrome_name + trace_name,
+                  process_metrics->GetWorkingSetSize(), "bytes",
+                  false /* not important */);
+#elif defined(OS_LINUX)
+      PrintResult("vm_size_final", chrome_name,
+                  "vm_size_f" + chrome_name + trace_name,
+                  process_metrics->GetPagefileUsage(), "bytes",
+                  true /* important */);
+      PrintResult("vm_rss_final", chrome_name,
+                  "vm_rss_f" + chrome_name + trace_name,
+                  process_metrics->GetWorkingSetSize(), "bytes",
+                  true /* important */);
+#else
+      NOTIMPLEMENTED();
+#endif
+      base::CloseProcessHandle(process_handle);
     }
   }
-#endif  // defined(OS_WIN)
 
   // When use_http is true, the test name passed here will be used directly in
   // the path to the test data, so it must be safe for use in a URL without
   // escaping. (No pound (#), question mark (?), semicolon (;), non-ASCII, or
   // other funny stuff.)
   void RunTest(const char* name, bool use_http) {
     std::wstring pages;
     std::string timings;
     RunPageCycler(name, &pages, &timings, use_http);
     if (timings.empty())
       return;
 
-#if defined(OS_WIN)
-    // TODO(port): Enable when Print{MemoryUsage,IOPerf}Info are ported.
     PrintMemoryUsageInfo("");
     PrintIOPerfInfo("");
-#endif  // defined(OS_WIN)
 
     wprintf(L"\nPages: [%ls]\n", pages.c_str());
     PrintResultList("times", "", "t", timings, "ms",
                     true /* important */);
   }
 };
 
 class PageCyclerReferenceTest : public PageCyclerTest {
  public:
   // override the browser directory that is used by UITest::SetUp to cause it
   // to use the reference build instead.
   void SetUp() {
     FilePath dir;
     PathService::Get(chrome::DIR_TEST_TOOLS, &dir);
     dir = dir.AppendASCII("reference_build");
+#if defined(OS_WIN)
     dir = dir.AppendASCII("chrome");
+#elif defined(OS_LINUX)
+    dir = dir.AppendASCII("chrome_linux");
+#elif defined(OS_MACOSX)
+    dir = dir.AppendASCII("chrome_mac");
+#endif
     browser_directory_ = dir;
     UITest::SetUp();
   }
 
   void RunTest(const char* name, bool use_http) {
     std::wstring pages;
     std::string timings;
     RunPageCycler(name, &pages, &timings, use_http);
     if (timings.empty())
       return;
 
-#if defined(OS_WIN)
-    // TODO(port): Enable when Print{MemoryUsage,IOPerf}Info are ported.
     PrintMemoryUsageInfo("_ref");
     PrintIOPerfInfo("_ref");
-#endif  // defined(OS_WIN)
 
     PrintResultList("times", "", "t_ref", timings, "ms",
                     true /* important */);
   }
 };
 
 
 // file-URL tests
 TEST_F(PageCyclerTest, MozFile) {
   RunTest("moz", false);
@@ skipping 86 matching lines @@
   RunTest("bloat", true);
 }
 
 #if !defined(OS_MACOSX)
 TEST_F(PageCyclerReferenceTest, BloatHttp) {
   RunTest("bloat", true);
 }
 #endif
 
 }  // namespace