Reliability test porting: stringy stuff....

chrome/test/reliability/page_load_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.
 //
 // This file provides reliablity test which runs under UI test framework. The
 // test is intended to run within QEMU environment.
 //
 // Usage 1: reliability_test
 // Upon invocation, it visits a hard coded list of sample URLs. This is mainly
 // used by buildbot, to verify reliability_test itself runs ok.
@@ skipping 24 matching lines @@
 
 #include <fstream>
 #include <iostream>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
+#include "base/test_file_util.h"
 #include "base/time.h"
 #include "base/time_format.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/common/logging_chrome.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/test/automation/automation_messages.h"
 #include "chrome/test/automation/automation_proxy.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/ui/ui_test.h"
 #include "chrome/test/perf/mem_usage.h"
 #include "chrome/test/reliability/page_load_test.h"
 #include "net/base/net_util.h"
 
+#if defined(OS_WIN)
+#define MAYBE_Reliability Reliability
+#else  // defined(OS_WIN)
+// TODO(estade): port till we can enable this.
+#define MAYBE_Reliability DISABLED_Reliability
+#endif  // !defined(OS_WIN)
+
 namespace {
 
 // See comments at the beginning of the file for the definition of switches.
 const wchar_t kSiteSwitch[] = L"site";
 const wchar_t kStartPageSwitch[] = L"startpage";
 const wchar_t kEndPageSwitch[] = L"endpage";
 const wchar_t kListSwitch[] = L"list";
 const wchar_t kStartIndexSwitch[] = L"startline";
 const wchar_t kEndIndexSwitch[] = L"endline";
 const wchar_t kIterationSwitch[] = L"iterations";
 const wchar_t kContinuousLoadSwitch[] = L"continuousload";
 const wchar_t kMemoryUsageSwitch[] = L"memoryusage";
 const wchar_t kEndURLSwitch[] = L"endurl";
 const wchar_t kLogFileSwitch[] = L"logfile";
 const wchar_t kTimeoutSwitch[] = L"timeout";
 const wchar_t kNoPageDownSwitch[] = L"nopagedown";
 const wchar_t kSaveDebugLogSwitch[] = L"savedebuglog";
 
-std::wstring server_url = L"http://urllist.com";
-const wchar_t test_page_1[] = L"page1.html";
-const wchar_t test_page_2[] = L"page2.html";
-const wchar_t crash_url[] = L"about:crash";
+const char kDefaultServerUrl[] = "http://urllist.com";
+char* server_url = NULL;
+const char kTestPage1[] = "page1.html";
+const char kTestPage2[] = "page2.html";
+const char crash_url[] = "about:crash";
 
 // These are copied from v8 definitions as we cannot include them.
 const wchar_t kV8LogFileSwitch[] = L"logfile";
-const wchar_t kV8LogFileDefaultName[] = L"v8.log";
+const char kV8LogFileDefaultName[] = "v8.log";
 
 // String name of local chrome dll for looking up file information.
-std::wstring kChromeDll = L"chrome.dll";
+const wchar_t kChromeDll[] = L"chrome.dll";
 
 bool append_page_id = false;
 int32 start_page;
 int32 end_page;
-std::wstring url_file_path;
+FilePath url_file_path;
 int32 start_index = 1;
 int32 end_index = kint32max;
 int32 iterations = 1;
 bool memory_usage = false;
 bool continuous_load = false;
 bool browser_existing = false;
 bool page_down = true;
-std::wstring end_url;
-std::wstring log_file_path;
-uint32 timeout_ms = INFINITE;
+GURL end_url;
+FilePath log_file_path;
+int timeout_ms = -1;
 bool save_debug_log = false;
-std::wstring chrome_log_path;
-std::wstring v8_log_path;
-std::wstring test_log_path;
+FilePath chrome_log_path;
+FilePath v8_log_path;
+FilePath test_log_path;
 bool stand_alone = false;
 
 class PageLoadTest : public UITest {
  public:
   enum NavigationResult {
     NAVIGATION_ERROR = 0,
     NAVIGATION_SUCCESS,
     NAVIGATION_AUTH_NEEDED,
     NAVIGATION_TIME_OUT,
   };
@@ skipping 10 matching lines @@
     int renderer_crash_count;
     int plugin_crash_count;
   } NavigationMetrics;
 
   PageLoadTest() {
     show_window_ = true;
   }
 
   // Accept URL as string here because the url may also act as a test id
   // and needs to be logged in its original format even if invalid.
-  void NavigateToURLLogResult(const std::wstring& url_string,
+  void NavigateToURLLogResult(const GURL& url,
                               std::ofstream& log_file,
                               NavigationMetrics* metrics_output) {
-    GURL url = GURL(url_string);
     NavigationMetrics metrics = {NAVIGATION_ERROR};
     std::ofstream test_log;
 
     // Create a test log.
-    test_log_path = L"test_log.log";
-    test_log.open(test_log_path.c_str());
+    test_log_path = FilePath(FILE_PATH_LITERAL("test_log.log"));
+    test_log.open(test_log_path.value().c_str());
 
+// TODO(estade): port.
+#if defined(OS_WIN)
     // Check file version info for chrome dll.
     FileVersionInfo* file_info;
     file_info = FileVersionInfo::CreateFileVersionInfo(kChromeDll);
     std::wstring last_change = file_info->last_change();
     test_log << "Last Change: ";
     test_log << last_change << std::endl;
+#endif  // defined(OS_WIN)
 
     // Log timestamp for test start.
     base::Time time_now = base::Time::Now();
     double time_start = time_now.ToDoubleT();
     test_log << "Test Start: ";
     test_log << base::TimeFormatFriendlyDateAndTime(time_now) << std::endl;
 
     if (!continuous_load && !browser_existing) {
       LaunchBrowserAndServer();
       browser_existing = true;
@@ skipping 20 matching lines @@
         if (page_down) {
           // Page down twice.
           scoped_refptr<BrowserProxy> browser(automation()->GetBrowserWindow(0));
           if (browser.get()) {
             scoped_refptr<WindowProxy> window(browser->GetWindow());
             if (window.get()) {
               bool activation_timeout;
               browser->BringToFrontWithTimeout(action_max_timeout_ms(),
                                                &activation_timeout);
               if (!activation_timeout) {
+// TODO(estade): port.
+#if defined(OS_WIN)
                 window->SimulateOSKeyPress(VK_NEXT, 0);
                 PlatformThread::Sleep(sleep_timeout_ms());
                 window->SimulateOSKeyPress(VK_NEXT, 0);
                 PlatformThread::Sleep(sleep_timeout_ms());
+#endif  // defined(OS_WIN)
               }
             }
           }
         }
       }
     }
 
     // Log navigate complete time.
     time_now = base::Time::Now();
     test_log << "navigate_complete_seconds=";
@@ skipping 35 matching lines @@
         case AUTOMATION_MSG_NAVIGATION_AUTH_NEEDED:
           metrics.result = NAVIGATION_AUTH_NEEDED;
           break;
         default:
           metrics.result = NAVIGATION_ERROR;
           break;
       }
     }
 
     if (log_file.is_open()) {
-      log_file << url_string;
+      log_file << url.spec();
       switch (metrics.result) {
         case NAVIGATION_ERROR:
           log_file << " error";
           break;
         case NAVIGATION_SUCCESS:
           log_file << " success";
           break;
         case NAVIGATION_AUTH_NEEDED:
           log_file << " auth_needed";
           break;
@@ skipping 16 matching lines @@
                << " " << 0 \
                << " " << metrics.plugin_crash_count \
                << " " << metrics.crash_dump_count;
     }
 
     // Close test log.
     test_log.close();
 
     if (log_file.is_open() && save_debug_log && !continuous_load)
       SaveDebugLogs(log_file);
-    
+
+// TODO(estade): port.
+#if defined(OS_WIN)
     // Log revision information for Chrome build under test.
     log_file << " " << "revision=" << last_change;
+#endif  // defined(OS_WIN)
 
     // Get crash dumps.
     LogOrDeleteNewCrashDumps(log_file, &metrics);
 
     if (log_file.is_open()) {
       log_file << std::endl;
     }
 
     if (metrics_output) {
       *metrics_output = metrics;
     }
   }
 
   void NavigateThroughPageID(std::ofstream& log_file) {
     if (append_page_id) {
       // For usage 2
       for (int i = start_page; i <= end_page; ++i) {
-        std::wstring test_page_url(
-            StringPrintf(L"%ls/page?id=%d", server_url.c_str(), i));
-        NavigateToURLLogResult(test_page_url, log_file, NULL);
+        const char* server = server_url ? server_url : kDefaultServerUrl;
+        std::string test_page_url(
+            StringPrintf("%s/page?id=%d", server, i));
+        NavigateToURLLogResult(GURL(test_page_url), log_file, NULL);
       }
     } else {
       // Don't run if single process mode.
       // Also don't run if running as a standalone program which is for
       // distributed testing, to avoid mistakenly hitting web sites with many
       // instances.
       if (in_process_renderer() || stand_alone)
         return;
       // For usage 1
       NavigationMetrics metrics;
-      if (timeout_ms == INFINITE)
+      if (timeout_ms == -1)
         timeout_ms = 2000;
 
       // Though it would be nice to test the page down code path in usage 1,
       // enabling page down adds several seconds to the test and does not seem
       // worth the tradeoff. It is also potentially disruptive when running the
       // test in the background as it will send the event to the window that
       // has focus.
       page_down = false;
 
       FilePath sample_data_dir = GetSampleDataDir();
-      FilePath test_page_1 = sample_data_dir.AppendASCII("page1.html");
-      FilePath test_page_2 = sample_data_dir.AppendASCII("page2.html");
+      FilePath test_page_1 = sample_data_dir.AppendASCII(kTestPage1);
+      FilePath test_page_2 = sample_data_dir.AppendASCII(kTestPage2);
 
       GURL test_url_1 = net::FilePathToFileURL(test_page_1);
       GURL test_url_2 = net::FilePathToFileURL(test_page_2);
 
-      // Convert back to string so that all calls to navigate are the same.
-      const std::wstring test_url_1_string = ASCIIToWide(test_url_1.spec());
-      const std::wstring test_url_2_string = ASCIIToWide(test_url_2.spec());
-
-      NavigateToURLLogResult(test_url_1_string, log_file, &metrics);
+      NavigateToURLLogResult(test_url_1, log_file, &metrics);
       // Verify everything is fine
       EXPECT_EQ(NAVIGATION_SUCCESS, metrics.result);
       EXPECT_EQ(0, metrics.crash_dump_count);
       EXPECT_EQ(true, metrics.browser_clean_exit);
       EXPECT_EQ(1, metrics.browser_launch_count);
       // Both starting page and test_url_1 are loaded.
       EXPECT_EQ(2, metrics.page_load_count);
       EXPECT_EQ(0, metrics.browser_crash_count);
       EXPECT_EQ(0, metrics.renderer_crash_count);
       EXPECT_EQ(0, metrics.plugin_crash_count);
 
       // Go to "about:crash"
-      NavigateToURLLogResult(std::wstring(crash_url), log_file, &metrics);
+      NavigateToURLLogResult(GURL(crash_url), log_file, &metrics);
       // Found a crash dump
       EXPECT_EQ(1, metrics.crash_dump_count) << kFailedNoCrashService;
       // Browser did not crash, and exited cleanly.
       EXPECT_EQ(true, metrics.browser_clean_exit);
       EXPECT_EQ(1, metrics.browser_launch_count);
       // Only the renderer should have crashed.
       EXPECT_EQ(0, metrics.browser_crash_count);
       EXPECT_EQ(1, metrics.renderer_crash_count);
       EXPECT_EQ(0, metrics.plugin_crash_count);
 
-      NavigateToURLLogResult(test_url_2_string, log_file, &metrics);
+      NavigateToURLLogResult(test_url_2, log_file, &metrics);
       // The data on previous crash should be cleared and we should get
       // metrics for a successful page load.
       EXPECT_EQ(NAVIGATION_SUCCESS, metrics.result);
       EXPECT_EQ(0, metrics.crash_dump_count);
       EXPECT_EQ(true, metrics.browser_clean_exit);
       EXPECT_EQ(1, metrics.browser_launch_count);
       EXPECT_EQ(0, metrics.browser_crash_count);
       EXPECT_EQ(0, metrics.renderer_crash_count);
       EXPECT_EQ(0, metrics.plugin_crash_count);
 
       // Verify metrics service does what we need when browser process crashes.
-      HANDLE browser_process;
       LaunchBrowserAndServer();
       {
         // TabProxy should be released before Browser is closed.
         scoped_refptr<TabProxy> tab_proxy(GetActiveTab());
         if (tab_proxy.get()) {
           tab_proxy->NavigateToURL(GURL(test_url_1));
         }
       }
       // Kill browser process.
-      browser_process = process();
-      TerminateProcess(browser_process, 0);
+      base::ProcessHandle browser_process = process();
+      base::KillProcess(browser_process, 0, false);
 
       GetStabilityMetrics(&metrics);
       // This is not a clean shutdown.
       EXPECT_EQ(false, metrics.browser_clean_exit);
       EXPECT_EQ(1, metrics.browser_crash_count);
       EXPECT_EQ(0, metrics.renderer_crash_count);
       EXPECT_EQ(0, metrics.plugin_crash_count);
       // Relaunch browser so UITest does not fire assertion during TearDown.
       LaunchBrowserAndServer();
     }
   }
 
   // For usage 3
   void NavigateThroughURLList(std::ofstream& log_file) {
-    std::ifstream file(url_file_path.c_str());
+    std::ifstream file(url_file_path.value().c_str());
     ASSERT_TRUE(file.is_open());
 
     for (int line_index = 1;
          line_index <= end_index && !file.eof();
          ++line_index) {
       std::string url_str;
       std::getline(file, url_str);
 
       if (file.fail())
         break;
 
       if (start_index <= line_index) {
-        NavigateToURLLogResult(ASCIIToWide(url_str), log_file, NULL);
+        NavigateToURLLogResult(GURL(url_str), log_file, NULL);
       }
     }
 
     file.close();
   }
 
  protected:
   // Call the base class's SetUp method and initialize our own class members.
   virtual void SetUp() {
     UITest::SetUp();
     browser_existing = true;
 
+// TODO(estade): port.
+#if defined(OS_WIN)
     // Initialize crash_dumps_dir_path_.
     PathService::Get(chrome::DIR_CRASH_DUMPS, &crash_dumps_dir_path_);
     // Initialize crash_dumps_.
     WIN32_FIND_DATAW find_data;
     HANDLE find_handle;
     std::wstring dir_spec(crash_dumps_dir_path_);
     dir_spec.append(L"\\*");  // list all files in the directory
     find_handle = FindFirstFileW(dir_spec.c_str(), &find_data);
     if (find_handle != INVALID_HANDLE_VALUE) {
       if (wcsstr(find_data.cFileName, L".dmp"))
         crash_dumps_[std::wstring(find_data.cFileName)] = true;
       while (FindNextFile(find_handle, &find_data)) {
         if (wcsstr(find_data.cFileName, L".dmp"))
           crash_dumps_[std::wstring(find_data.cFileName)] = true;
       }
       FindClose(find_handle);
     }
+#endif  // defined(OS_WIN)
   }
 
   FilePath ConstructSavedDebugLogPath(const FilePath& debug_log_path,
                                       int index) {
-    std::wstring suffix(L"_");
-    suffix.append(IntToWString(index));
-    return debug_log_path.InsertBeforeExtension(suffix);
+    std::string suffix("_");
+    suffix.append(IntToString(index));
+    return debug_log_path.InsertBeforeExtensionASCII(suffix);
   }
 
-  void SaveDebugLog(const std::wstring& log_path, const std::wstring& log_id,
+  void SaveDebugLog(const FilePath& log_path, const std::wstring& log_id,
                     std::ofstream& log_file, int index) {
     if (!log_path.empty()) {
-      FilePath log_file_path(log_path);
       FilePath saved_log_file_path =
-          ConstructSavedDebugLogPath(log_file_path, index);
+          ConstructSavedDebugLogPath(log_path, index);
       if (file_util::Move(log_file_path, saved_log_file_path)) {
         log_file << " " << log_id << "=" << saved_log_file_path.value();
       }
     }
   }
 
   // Rename the chrome and v8 debug log files if existing, and save the file
   // paths in the log_file provided.
   void SaveDebugLogs(std::ofstream& log_file) {
     static int url_count = 1;
     SaveDebugLog(chrome_log_path, L"chrome_log", log_file, url_count);
     SaveDebugLog(v8_log_path, L"v8_log", log_file, url_count);
     SaveDebugLog(test_log_path, L"test_log", log_file, url_count);
     url_count++;
   }
 
   // If a log_file is provided, log the crash dump with the given path;
   // otherwise, delete the crash dump file.
   void LogOrDeleteCrashDump(std::ofstream& log_file,
                             std::wstring crash_dump_file_name) {
-
     std::wstring crash_dump_file_path(crash_dumps_dir_path_);
     crash_dump_file_path.append(L"\\");
     crash_dump_file_path.append(crash_dump_file_name);
     std::wstring crash_text_file_path(crash_dump_file_path);
     crash_text_file_path.replace(crash_text_file_path.length() - 3,
                                  3, L"txt");
 
     if (log_file.is_open()) {
       crash_dumps_[crash_dump_file_name] = true;
       log_file << " crash_dump=" << crash_dump_file_path;
     } else {
-      ASSERT_TRUE(DeleteFileW(crash_dump_file_path.c_str()));
-      ASSERT_TRUE(DeleteFileW(crash_text_file_path.c_str()));
+      ASSERT_TRUE(file_util::DieFileDie(crash_dump_file_path, false));
+      ASSERT_TRUE(file_util::DieFileDie(crash_text_file_path, false));
     }
   }
 
   // Check whether there are new .dmp files. Additionally, write
   //     " crash_dump=<full path name of the .dmp file>"
   // to log_file.
   void LogOrDeleteNewCrashDumps(std::ofstream& log_file,
                                 NavigationMetrics* metrics) {
+// TODO(estade): port.
+#if defined(OS_WIN)
     WIN32_FIND_DATAW find_data;
     HANDLE find_handle;
     int num_dumps = 0;
 
     std::wstring dir_spec(crash_dumps_dir_path_);
     dir_spec.append(L"\\*");  // list all files in the directory
     find_handle = FindFirstFileW(dir_spec.c_str(), &find_data);
     if (find_handle != INVALID_HANDLE_VALUE) {
       if (wcsstr(find_data.cFileName, L".dmp") &&
           !crash_dumps_[std::wstring(find_data.cFileName)]) {
         LogOrDeleteCrashDump(log_file, find_data.cFileName);
         num_dumps++;
       }
       while (FindNextFile(find_handle, &find_data)) {
         if (wcsstr(find_data.cFileName, L".dmp") &&
             !crash_dumps_[std::wstring(find_data.cFileName)]) {
           LogOrDeleteCrashDump(log_file, find_data.cFileName);
           num_dumps++;
         }
       }
       FindClose(find_handle);
     }
 
     if (metrics)
       metrics->crash_dump_count = num_dumps;
+#endif  // defined(OS_WIN)
   }
 
   // Get a PrefService whose contents correspond to the Local State file
   // that was saved by the app as it closed.  The caller takes ownership of the
   // returned PrefService object.
   PrefService* GetLocalState() {
     FilePath local_state_path = user_data_dir()
         .Append(chrome::kLocalStateFilename);
 
     PrefService* local_state(new PrefService(local_state_path, NULL));
@@ skipping 47 matching lines @@
   // The set is implemented as a std::map.  The key is the file name, and
   // the value is false (the file is not in the set) or true (the file is
   // in the set).  The initial value for any key in std::map is 0 (false),
   // which in this case means a new file is not in the set initially,
   // exactly the semantics we want.
   std::map<std::wstring, bool> crash_dumps_;
 };
 
 }  // namespace
 
-TEST_F(PageLoadTest, Reliability) {
+TEST_F(PageLoadTest, MAYBE_Reliability) {
   std::ofstream log_file;
 
   if (!log_file_path.empty()) {
-    log_file.open(log_file_path.c_str());
+    log_file.open(log_file_path.value().c_str());
   }
 
   for (int k = 0; k < iterations; ++k) {
     if (url_file_path.empty()) {
       NavigateThroughPageID(log_file);
     } else {
       NavigateThroughURLList(log_file);
     }
 
+// TODO(estade): port.
+#if defined(OS_WIN)
     if (memory_usage)
       PrintChromeMemoryUsageInfo();
+#endif  // defined(OS_WIN)
   }
 
-  if (!end_url.empty()) {
+  if (!end_url.is_empty()) {
     NavigateToURLLogResult(end_url, log_file, NULL);
   }
 
   log_file.close();
 }
 
 namespace {
   void ReportHandler(const std::string& str) {
     // Ignore report events.
   }
 }
 
 void SetPageRange(const CommandLine& parsed_command_line) {
   // If calling into this function, we are running as a standalone program.
   stand_alone = true;
 
   // Since we use --enable-dcheck for reliability tests, suppress the error
   // dialog in the test process.
   logging::SetLogReportHandler(ReportHandler);
 
   if (parsed_command_line.HasSwitch(kStartPageSwitch)) {
     ASSERT_TRUE(parsed_command_line.HasSwitch(kEndPageSwitch));
-    start_page =
-        _wtoi(parsed_command_line.GetSwitchValue(kStartPageSwitch).c_str());
-    end_page =
-        _wtoi(parsed_command_line.GetSwitchValue(kEndPageSwitch).c_str());
+    ASSERT_TRUE(
+        StringToInt(WideToUTF16(parsed_command_line.GetSwitchValue(
+            kStartPageSwitch)), &start_page));
+    ASSERT_TRUE(
+        StringToInt(WideToUTF16(parsed_command_line.GetSwitchValue(
+            kEndPageSwitch)), &end_page));
     ASSERT_TRUE(start_page > 0 && end_page > 0);
     ASSERT_TRUE(start_page < end_page);
     append_page_id = true;
   } else {
     ASSERT_FALSE(parsed_command_line.HasSwitch(kEndPageSwitch));
   }
 
-  if (parsed_command_line.HasSwitch(kSiteSwitch))
-    server_url.assign(parsed_command_line.GetSwitchValue(kSiteSwitch));
+  if (parsed_command_line.HasSwitch(kSiteSwitch)) {
+    server_url =
+        strdup(WideToUTF8(parsed_command_line.GetSwitchValue(kSiteSwitch)));
+  }
 
   if (parsed_command_line.HasSwitch(kStartIndexSwitch)) {
-    start_index =
-        _wtoi(parsed_command_line.GetSwitchValue(kStartIndexSwitch).c_str());
+    ASSERT_TRUE(
+        StringToInt(WideToUTF16(parsed_command_line.GetSwitchValue(
+            kStartIndexSwitch)), &start_index));
     ASSERT_TRUE(start_index > 0);
   }
 
   if (parsed_command_line.HasSwitch(kEndIndexSwitch)) {
-    end_index =
-        _wtoi(parsed_command_line.GetSwitchValue(kEndIndexSwitch).c_str());
+    ASSERT_TRUE(
+        StringToInt(WideToUTF16(parsed_command_line.GetSwitchValue(
+            kEndIndexSwitch)), &end_index));
     ASSERT_TRUE(end_index > 0);
   }
 
   ASSERT_TRUE(end_index >= start_index);
 
-  if (parsed_command_line.HasSwitch(kListSwitch))
-    url_file_path.assign(parsed_command_line.GetSwitchValue(kListSwitch));
+  if (parsed_command_line.HasSwitch(kListSwitch)) {
+    url_file_path = FilePath::FromWStringHack(
+        parsed_command_line.GetSwitchValue(kListSwitch));
+  }
 
   if (parsed_command_line.HasSwitch(kIterationSwitch)) {
-    iterations =
-        _wtoi(parsed_command_line.GetSwitchValue(kIterationSwitch).c_str());
+    ASSERT_TRUE(
+        StringToInt(WideToUTF16(parsed_command_line.GetSwitchValue(
+            kIterationSwitch)), &iterations));
     ASSERT_TRUE(iterations > 0);
   }
 
   if (parsed_command_line.HasSwitch(kMemoryUsageSwitch))
     memory_usage = true;
 
   if (parsed_command_line.HasSwitch(kContinuousLoadSwitch))
     continuous_load = true;
 
-  if (parsed_command_line.HasSwitch(kEndURLSwitch))
-    end_url.assign(parsed_command_line.GetSwitchValue(kEndURLSwitch));
+  if (parsed_command_line.HasSwitch(kEndURLSwitch)) {
+    end_url = GURL(WideToUTF8(
+        parsed_command_line.GetSwitchValue(kEndURLSwitch)));
+  }
 
-  if (parsed_command_line.HasSwitch(kLogFileSwitch))
-    log_file_path.assign(parsed_command_line.GetSwitchValue(kLogFileSwitch));
+  if (parsed_command_line.HasSwitch(kLogFileSwitch)) {
+    log_file_path =
+        FilePath::FromWStringHack(parsed_command_line.GetSwitchValue(kLogFileSwitch));
+  }
 
   if (parsed_command_line.HasSwitch(kTimeoutSwitch)) {
-    timeout_ms =
-        _wtoi(parsed_command_line.GetSwitchValue(kTimeoutSwitch).c_str());
+    ASSERT_TRUE(
+        StringToInt(WideToUTF16(parsed_command_line.GetSwitchValue(
+            kTimeoutSwitch)), &timeout_ms));
     ASSERT_TRUE(timeout_ms > 0);
   }
 
   if (parsed_command_line.HasSwitch(kNoPageDownSwitch))
     page_down = false;
 
   if (parsed_command_line.HasSwitch(kSaveDebugLogSwitch)) {
     save_debug_log = true;
     chrome_log_path = logging::GetLogFileName();
     // We won't get v8 log unless --no-sandbox is specified.
     if (parsed_command_line.HasSwitch(switches::kNoSandbox)) {
       PathService::Get(base::DIR_CURRENT, &v8_log_path);
-      file_util::AppendToPath(&v8_log_path, kV8LogFileDefaultName);
+      v8_log_path = v8_log_path.AppendASCII(kV8LogFileDefaultName);
       // The command line switch may override the default v8 log path.
       if (parsed_command_line.HasSwitch(switches::kJavaScriptFlags)) {
         CommandLine v8_command_line(
             parsed_command_line.GetSwitchValue(switches::kJavaScriptFlags));
         if (v8_command_line.HasSwitch(kV8LogFileSwitch)) {
-          v8_log_path = v8_command_line.GetSwitchValue(kV8LogFileSwitch);
+          v8_log_path = FilePath::FromWStringHack(
+              v8_command_line.GetSwitchValue(kV8LogFileSwitch));
           if (!file_util::AbsolutePath(&v8_log_path)) {
-            v8_log_path.clear();
+            v8_log_path = FilePath();
           }
         }
       }
     }
   }
 }