Reliability test porting: stringy stuff....

chrome/common/logging_chrome.cc

 // Copyright (c) 2006-2008 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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include <iostream>
 #include <fstream>
 
 #include "chrome/common/logging_chrome.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug_util.h"
+#include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/env_vars.h"
 #include "ipc/ipc_message.h"
 
@@ skipping 78 matching lines @@
     // Let --enable-logging=stderr force only stderr, particularly useful for
     // non-debug builds where otherwise you can't get logs to stderr at all.
     if (command_line.GetSwitchValue(switches::kEnableLogging) == L"stderr")
       log_mode = logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG;
     else
       log_mode = kDefaultLoggingMode;
   } else {
     log_mode = logging::LOG_NONE;
   }
 
-#if defined(OS_POSIX)
-  std::string log_file_name = WideToUTF8(GetLogFileName());
-#elif defined(OS_WIN)
-  std::wstring log_file_name = GetLogFileName();
-#endif
-
-  logging::InitLogging(log_file_name.c_str(),
+  logging::InitLogging(GetLogFileName().value().c_str(),
                        log_mode,
                        logging::LOCK_LOG_FILE,
                        delete_old_log_file);
 
   // we want process and thread IDs because we have a lot of things running
   logging::SetLogItems(true, true, false, true);
 
   // We call running in unattended mode "headless", and allow
   // headless mode to be configured either by the Environment
   // Variable or by the Command Line Switch.  This is for
@@ skipping 24 matching lines @@
 // we need to do more cleanup in the future.
 void CleanupChromeLogging() {
   DCHECK(chrome_logging_initialized_) <<
     "Attempted to clean up logging when it wasn't initialized.";
 
   CloseLogFile();
 
   chrome_logging_initialized_ = false;
 }
 
-std::wstring GetLogFileName() {
+FilePath GetLogFileName() {
   std::wstring filename = base::SysInfo::GetEnvVar(env_vars::kLogFileName);
-  if (filename != L"")
-    return filename;
+  if (!filename.empty())
+    return FilePath::FromWStringHack(filename);
 
-  const std::wstring log_filename(L"chrome_debug.log");
-  std::wstring log_path;
+  const FilePath log_filename(FILE_PATH_LITERAL("chrome_debug.log"));
+  FilePath log_path;
 
   if (PathService::Get(chrome::DIR_LOGS, &log_path)) {
-    file_util::AppendToPath(&log_path, log_filename);
+    log_path = log_path.Append(log_filename);
     return log_path;
   } else {
     // error with path service, just use some default file somewhere
     return log_filename;
   }
 }
 
 bool DialogsAreSuppressed() {
   return dialogs_are_suppressed_;
 }
 
 size_t GetFatalAssertions(AssertionList* assertions) {
   // In this function, we don't assume that assertions is non-null, so
   // that if you just want an assertion count, you can pass in NULL.
   if (assertions)
     assertions->clear();
   size_t assertion_count = 0;
 
   std::ifstream log_file;
-#if defined(OS_WIN)
-  log_file.open(GetLogFileName().c_str());
-#elif defined(OS_POSIX)
-  log_file.open(WideToUTF8(GetLogFileName()).c_str());
-#endif
+  log_file.open(GetLogFileName().value().c_str());
   if (!log_file.is_open())
     return 0;
 
   std::string utf8_line;
   std::wstring wide_line;
   while(!log_file.eof()) {
     getline(log_file, utf8_line);
     if (utf8_line.find(":FATAL:") != std::string::npos) {
       wide_line = UTF8ToWide(utf8_line);
       if (assertions)
         assertions->push_back(wide_line);
       ++assertion_count;
     }
   }
   log_file.close();
 
   return assertion_count;
 }
 
 } // namespace logging