Start to get memory test compiling on mac & linux....

chrome/test/memory_test/memory_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/file_util.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/browser_proxy.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"
+#if defined(OS_WIN)
 #include "chrome/test/perf/mem_usage.h"
+#endif
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 
 namespace {
 
-static const wchar_t kTempDirName[] = L"memory_test_profile";
+static const FilePath::CharType kTempDirName[] =
+    FILE_PATH_LITERAL("memory_test_profile");
 
 class MemoryTest : public UITest {
  public:
   MemoryTest() : cleanup_temp_dir_on_exit_(false) {
     show_window_ = true;
 
     // For now, turn off plugins because they crash like crazy.
     // TODO(mbelshe): Fix Chrome to not crash with plugins.
     launch_arguments_.AppendSwitch(switches::kDisablePlugins);
 
     launch_arguments_.AppendSwitch(switches::kEnableLogging);
 
     // Use the playback cache, but don't use playback events.
     launch_arguments_.AppendSwitch(switches::kPlaybackMode);
     launch_arguments_.AppendSwitch(switches::kNoEvents);
 
     // Get the specified user data dir (optional)
-    std::wstring profile_dir =
-      CommandLine::ForCurrentProcess()->GetSwitchValue(switches::kUserDataDir);
+    FilePath profile_dir = FilePath::FromWStringHack(
+      CommandLine::ForCurrentProcess()->GetSwitchValue(switches::kUserDataDir));
 
-    if (profile_dir.length() == 0) {
+    if (profile_dir.empty()) {
       // Compute the user-data-dir which contains our test cache.
       PathService::Get(base::DIR_EXE, &profile_dir);
-      file_util::UpOneDirectory(&profile_dir);
-      file_util::UpOneDirectory(&profile_dir);
-      file_util::AppendToPath(&profile_dir, L"data");
-      file_util::AppendToPath(&profile_dir, L"memory_test");
-      file_util::AppendToPath(&profile_dir, L"general_mix");
+      profile_dir = profile_dir.DirName();
+      profile_dir = profile_dir.DirName();
+      profile_dir = profile_dir.AppendASCII("data");
+      profile_dir = profile_dir.AppendASCII("memory_test");
+      profile_dir = profile_dir.AppendASCII("general_mix");
 
       if (!SetupTempDirectory(profile_dir)) {
         // There isn't really a way to fail gracefully here.
         // Neither this constuctor nor the SetUp() method return
         // status to the caller.  So, just fall through using the
         // default profile and log this.  The failure will be
         // obvious.
         LOG(ERROR) << "Error preparing temp directory for test";
       }
     }
 
     launch_arguments_.AppendSwitchWithValue(switches::kUserDataDir,
-                                            user_data_dir_);
+                                            user_data_dir_.ToWStringHack());
   }
 
   ~MemoryTest() {
     // Cleanup our temporary directory.
     if (cleanup_temp_dir_on_exit_)
       file_util::Delete(user_data_dir_, true);
   }
 
   // TODO(mbelshe): Separate this data to an external file.
   // This memory test loads a set of URLs across a set of tabs, maintaining the
@@ skipping 125 matching lines @@
       "http://pt.wikipedia.org/wiki/P%C3%A1gina_principal",
       "http://es.wikipedia.org/wiki/Portada",
       "http://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B3%D0%BB%D0%B0%D0%B2%D0%BD%D0%B0%D1%8F_%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86%D0%B0",
       "<NEWTAB>",
       "http://www.google.com/translate_t?hl=en&text=This%20Is%20A%20Test%20Of%20missspellingsdfdf&sl=en&tl=ja",
     };
 
     // Record the initial CommitCharge.  This is a system-wide measurement,
     // so if other applications are running, they can create variance in this
     // test.
+#if defined(OS_WIN)
     size_t start_size = GetSystemCommitCharge();
+#endif
 
     // Cycle through the URLs.
     scoped_refptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
     scoped_refptr<TabProxy> tab(window->GetActiveTab());
     int expected_tab_count = 1;
     for (unsigned counter = 0; counter < arraysize(urls); ++counter) {
       std::string url = urls[counter];
 
       if (url == "<PAUSE>") {  // Special command to delay on this page
         PlatformThread::Sleep(2000);
@@ skipping 22 matching lines @@
       tab->NavigateToURLWithTimeout(GURL(urls[counter]), kMaxWaitTime,
                                     &timed_out);
       if (timed_out)
         printf("warning: %s timed out!\n", urls[counter].c_str());
 
       // TODO(mbelshe): Bug 2953
       // The automation crashes periodically if we cycle too quickly.
       // To make these tests more reliable, slowing them down a bit.
       PlatformThread::Sleep(100);
     }
+#if defined(OS_WIN)
     size_t stop_size = GetSystemCommitCharge();
 
     PrintResults(test_name, stop_size - start_size);
+#else
+    NOTIMPLEMENTED() << "need to map SystemCommitCharge";
+    PrintResults(test_name, 0);
+#endif
   }
 
   void PrintResults(const char* test_name, size_t commit_size) {
     PrintMemoryUsageInfo(test_name);
     std::string trace_name(test_name);
     trace_name.append("_cc");
 
     PrintResult("commit_charge", "", trace_name,
                 commit_size / 1024, "kb", true /* important */);
   }
 
   void PrintIOPerfInfo(const char* test_name) {
     printf("\n");
 
     FilePath data_dir(user_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) {
       scoped_ptr<base::ProcessMetrics> process_metrics;
-      IO_COUNTERS io_counters;
+      IoCounters io_counters;
       base::ProcessHandle process_handle;
       if (!base::OpenProcessHandle(*it, &process_handle)) {
         NOTREACHED();
       }
       process_metrics.reset(
           base::ProcessMetrics::CreateProcessMetrics(process_handle));
-      ZeroMemory(&io_counters, sizeof(io_counters));
+      bzero(&io_counters, sizeof(io_counters));
 
       if (process_metrics.get()->GetIOCounters(&io_counters)) {
         std::string chrome_name = (*it == browser_process_pid) ? "_b" : "_r";
 
         // Print out IO performance.  We assume that the values can be
         // converted to size_t (they're reported as ULONGLONG, 64-bit numbers).
         PrintResult("read_op", chrome_name, test_name + chrome_name,
                     static_cast<size_t>(io_counters.ReadOperationCount), "",
                     false /* not important */);
         PrintResult("write_op", chrome_name, test_name + chrome_name,
@@ skipping 14 matching lines @@
       }
 
       base::CloseProcessHandle(process_handle);
     }
   }
 
   void PrintMemoryUsageInfo(const char* test_name) {
     printf("\n");
 
     FilePath data_dir(user_data_dir());
+#if defined(OS_WIN)
     int browser_process_pid = ChromeBrowserProcessId(data_dir);
+#endif
     ChromeProcessList chrome_processes(GetRunningChromeProcesses(data_dir));
 
     size_t browser_virtual_size = 0;
     size_t browser_working_set_size = 0;
     size_t virtual_size = 0;
     size_t working_set_size = 0;
     size_t num_chrome_processes = 0;
     ChromeProcessList::const_iterator it;
     for (it = chrome_processes.begin(); it != chrome_processes.end(); ++it) {
+#if defined(OS_WIN)
       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)) {
         if (*it == browser_process_pid) {
           browser_virtual_size = current_virtual_size;
           browser_working_set_size = current_working_set_size;
         }
         virtual_size += current_virtual_size;
         working_set_size += current_working_set_size;
         num_chrome_processes++;
       }
+#else
+      // TODO(port)
+      NOTIMPLEMENTED()
+        << "need to port GetMemoryInfo or map it to the existing primitives";
+#endif
     }
 
     std::string trace_name(test_name);
     PrintResult("vm_final_browser", "", trace_name + "_vm_b",
                 browser_virtual_size / 1024, "kb",
                 false /* not important */);
     PrintResult("ws_final_browser", "", trace_name + "_ws_b",
                 browser_working_set_size / 1024, "kb",
                 false /* not important */);
     PrintResult("vm_final_total", "", trace_name + "_vm",
                 virtual_size / 1024, "kb",
                 false /* not important */);
     PrintResult("ws_final_total", "", trace_name + "_ws",
                 working_set_size / 1024, "kb",
                 true /* important */);
     PrintResult("processes", "", trace_name + "_proc",
                 num_chrome_processes, "",
                 false /* not important */);
   }
 
  private:
   // Setup a temporary directory to store the profile to use
   // with these tests.
   // Input:
   //   src_dir is set to the source directory
   // Output:
   //   On success, modifies user_data_dir_ to be a new profile directory
   //   and sets cleanup_temp_dir_on_exit_ to true.
-  bool SetupTempDirectory(std::wstring src_dir) {
-    LOG(INFO) << "Setting up temp directory in " << src_dir.c_str();
+  bool SetupTempDirectory(const FilePath &src_dir) {
+    LOG(INFO) << "Setting up temp directory in " << src_dir.value();
     // We create a copy of the test dir and use it so that each
     // run of this test starts with the same data.  Running this
     // test has the side effect that it will change the profile.
-    std::wstring temp_dir;
+    FilePath temp_dir;
     if (!file_util::CreateNewTempDirectory(kTempDirName, &temp_dir)) {
       LOG(ERROR) << "Could not create temp directory:" << kTempDirName;
       return false;
     }
 
-    src_dir.append(L"\\*");
-
     if (!file_util::CopyDirectory(src_dir, temp_dir, true)) {
       LOG(ERROR) << "Could not copy temp directory";
       return false;
     }
 
     user_data_dir_ = temp_dir;
     cleanup_temp_dir_on_exit_ = true;
     LOG(INFO) << "Finished temp directory setup.";
     return true;
   }
 
   bool cleanup_temp_dir_on_exit_;
-  std::wstring user_data_dir_;
+  FilePath user_data_dir_;
 };
 
 class MemoryReferenceTest : public MemoryTest {
  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* test_name, int num_target_tabs) {
     std::wstring pages, timings;
     MemoryTest::RunTest(test_name, num_target_tabs);
   }
 };
 
-}  // namespace
-
 TEST_F(MemoryTest, SingleTabTest) {
   RunTest("1t", 1);
 }
 
 TEST_F(MemoryTest, FiveTabTest) {
   RunTest("5t", 5);
 }
 
 TEST_F(MemoryTest, TwelveTabTest) {
   RunTest("12t", 12);
 }
+
+}  // namespace