This moves log output for ChromeOS to safer locations.

chrome/common/logging_chrome.cc

 // Copyright (c) 2010 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"
 
 // Need to include this before most other files because it defines
 // IPC_MESSAGE_LOG_ENABLED. We need to use it to define
 // IPC_MESSAGE_MACROS_LOG_ENABLED so render_messages.h will generate the
 // ViewMsgLog et al. functions.
@@ skipping 140 matching lines @@
 }
 
 FilePath SetUpSymlinkIfNeeded(const FilePath& symlink_path, bool new_log) {
   DCHECK(!symlink_path.empty());
 
   // If not starting a new log, then just log through the existing
   // symlink, but if the symlink doesn't exist, create it.  If
   // starting a new log, then delete the old symlink and make a new
   // one to a fresh log file.
   FilePath target_path;
-  if (new_log || !file_util::PathExists(symlink_path)) {
+  bool symlink_exists = file_util::PathExists(symlink_path);
+  if (new_log || !symlink_exists) {
     target_path = GenerateTimestampedName(symlink_path, base::Time::Now());
 
     // We don't care if the unlink fails; we're going to continue anyway.
     if (unlink(symlink_path.value().c_str()) == -1) {
-      if (new_log) // only warn if we might expect it to succeed.
+      if (symlink_exists) // only warn if we might expect it to succeed.
         PLOG(WARNING) << "Unable to unlink " << symlink_path.value();
     }
     if (symlink(target_path.value().c_str(),
                 symlink_path.value().c_str()) == -1) {
       PLOG(ERROR) << "Unable to create symlink " << symlink_path.value()
                   << " pointing at " << target_path.value();
     }
   } else {
     char buf[PATH_MAX];
     ssize_t count = readlink(symlink_path.value().c_str(), buf, arraysize(buf));
     if (count > 0) {
       target_path = FilePath(FilePath::StringType(buf, count));
     } else {
       PLOG(ERROR) << "Unable to read symlink " << symlink_path.value();
     }
   }
   return target_path;
 }
 
 void RemoveSymlinkAndLog(const FilePath& link_path,
                          const FilePath& target_path) {
   if (::unlink(link_path.value().c_str()) == -1)
     PLOG(WARNING) << "Unable to unlink symlink " << link_path.value();
   if (::unlink(target_path.value().c_str()) == -1)
     PLOG(WARNING) << "Unable to unlink log file " << target_path.value();
 }
 
 }  // anonymous namespace
 
-void RedirectChromeLogging(const FilePath& new_log_dir,
-                           const CommandLine& command_line) {
+FilePath GetSessionLogFile(const CommandLine& command_line) {
+  FilePath log_dir;
+  std::string log_dir_str;
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  if (env->GetVar(env_vars::kSessionLogDir, &log_dir_str) &&
+      !log_dir_str.empty()) {
+    log_dir = FilePath(log_dir_str);
+  } else {
+    PathService::Get(chrome::DIR_USER_DATA, &log_dir);
+    FilePath login_profile =
+        command_line.GetSwitchValuePath(switches::kLoginProfile);
+    log_dir = log_dir.Append(login_profile);
+  }
+  return log_dir.Append(GetLogFileName().BaseName());
+}
+
+void RedirectChromeLogging(const CommandLine& command_line) {
   DCHECK(!chrome_logging_redirected_) <<
     "Attempted to redirect logging when it was already initialized.";
-  FilePath orig_log_path = GetLogFileName();
-  FilePath log_path = new_log_dir.Append(orig_log_path.BaseName());
+
+  // Redirect logs to the session log directory, if set.  Otherwise
+  // defaults to the profile dir.
+  FilePath log_path = GetSessionLogFile(command_line);
 
   // Always force a new symlink when redirecting.
   FilePath target_path = SetUpSymlinkIfNeeded(log_path, true);
 
   // ChromeOS always logs through the symlink, so it shouldn't be
   // deleted if it already exists.
   if (!InitLogging(log_path.value().c_str(),
                    DetermineLogMode(command_line),
                    logging::LOCK_LOG_FILE,
                    logging::APPEND_TO_OLD_LOG_FILE)) {
     LOG(ERROR) << "Unable to initialize logging to " << log_path.value();
     RemoveSymlinkAndLog(log_path, target_path);
   } else {
     chrome_logging_redirected_ = true;
   }
 }
+
+
 #endif
 
 void InitChromeLogging(const CommandLine& command_line,
                        OldFileDeletionState delete_old_log_file) {
   DCHECK(!chrome_logging_initialized_) <<
     "Attempted to initialize logging when it was already initialized.";
 
 #if defined(OS_POSIX) && defined(IPC_MESSAGE_LOG_ENABLED)
   IPC::Logging::SetLoggerFunctions(g_log_function_mapping);
 #endif
 
   FilePath log_path = GetLogFileName();
 
 #if defined(OS_CHROMEOS)
+  // For BWSI (Incognito) logins, we want to put the logs in the user
+  // profile directory that is created for the temporary session instead
+  // of in the system log directory, for privacy reasons.
+  if (command_line.HasSwitch(switches::kGuestSession))
+    log_path = GetSessionLogFile(command_line);
+
   // On ChromeOS we log to the symlink.  We force creation of a new
   // symlink if we've been asked to delete the old log, since that
   // indicates the start of a new session.
   FilePath target_path = SetUpSymlinkIfNeeded(
       log_path, delete_old_log_file == logging::DELETE_OLD_LOG_FILE);
 
   // Because ChromeOS manages the move to a new session by redirecting
   // the link, it shouldn't remove the old file in the logging code,
   // since that will remove the newly created link instead.
   delete_old_log_file = logging::APPEND_TO_OLD_LOG_FILE;
@@ skipping 121 matching lines @@
         assertions->push_back(wide_line);
       ++assertion_count;
     }
   }
   log_file.close();
 
   return assertion_count;
 }
 
 }  // namespace logging