blob: 909587355302e388755ff5719ee075a9c3f75192 [file] [log] [blame]
[email protected]0f65b52d2012-02-09 21:02:471// Copyright (c) 2012 The Chromium Authors. All rights reserved.
license.botbf09a502008-08-24 00:55:552// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit09911bf2008-07-26 23:55:294
[email protected]ec657802008-11-07 20:05:395#include "build/build_config.h"
6
[email protected]d55aaa132009-09-28 21:08:047// Need to include this before most other files because it defines
8// IPC_MESSAGE_LOG_ENABLED. We need to use it to define
9// IPC_MESSAGE_MACROS_LOG_ENABLED so render_messages.h will generate the
10// ViewMsgLog et al. functions.
11#include "ipc/ipc_message.h"
12
13// On Windows, the about:ipc dialog shows IPCs; on POSIX, we hook up a
14// logger in this file. (We implement about:ipc on Mac but implement
15// the loggers here anyway). We need to do this real early to be sure
16// IPC_MESSAGE_MACROS_LOG_ENABLED doesn't get undefined.
17#if defined(OS_POSIX) && defined(IPC_MESSAGE_LOG_ENABLED)
18#define IPC_MESSAGE_MACROS_LOG_ENABLED
[email protected]4f68ed72012-10-30 05:24:0719#include "content/public/common/content_ipc_logging.h"
20#define IPC_LOG_TABLE_ADD_ENTRY(msg_id, logger) \
21 content::RegisterIPCLogger(msg_id, logger)
[email protected]4a6d74152011-09-26 20:42:3022#include "chrome/common/all_messages.h"
[email protected]d55aaa132009-09-28 21:08:0423#endif
24
[email protected]ec657802008-11-07 20:05:3925#if defined(OS_WIN)
initial.commit09911bf2008-07-26 23:55:2926#include <windows.h>
[email protected]ec657802008-11-07 20:05:3927#endif
initial.commit09911bf2008-07-26 23:55:2928
initial.commit09911bf2008-07-26 23:55:2929#include <fstream>
30
31#include "chrome/common/logging_chrome.h"
32
33#include "base/command_line.h"
[email protected]0eb9f4342008-11-21 18:48:5234#include "base/compiler_specific.h"
[email protected]58580352010-10-26 04:07:5035#include "base/debug/debugger.h"
[email protected]76b90d312010-08-03 03:00:5036#include "base/environment.h"
initial.commit09911bf2008-07-26 23:55:2937#include "base/file_util.h"
[email protected]57999812013-02-24 05:40:5238#include "base/files/file_path.h"
initial.commit09911bf2008-07-26 23:55:2939#include "base/logging.h"
40#include "base/path_service.h"
[email protected]5d91c9e2010-07-28 17:25:2841#include "base/string_util.h"
[email protected]92e43a042011-08-17 00:36:4042#include "base/stringprintf.h"
[email protected]3ea1b182013-02-08 22:38:4143#include "base/strings/string_number_conversions.h"
[email protected]61f93212011-01-24 14:37:0844#include "base/threading/thread_restrictions.h"
[email protected]77ee1b12010-06-14 16:21:3045#include "base/time.h"
[email protected]4197e092010-03-10 00:35:0546#include "base/utf_string_conversions.h"
[email protected]ab7ee5b2011-03-01 22:24:1447#include "chrome/common/chrome_constants.h"
initial.commit09911bf2008-07-26 23:55:2948#include "chrome/common/chrome_paths.h"
49#include "chrome/common/chrome_switches.h"
[email protected]fe69aa12013-02-01 03:37:2750#include "chrome/common/dump_without_crashing.h"
initial.commit09911bf2008-07-26 23:55:2951#include "chrome/common/env_vars.h"
[email protected]51d5e162009-07-27 19:23:5452#include "ipc/ipc_logging.h"
[email protected]ab7ee5b2011-03-01 22:24:1453
[email protected]931d1042013-04-05 17:50:4454#if defined(OS_CHROMEOS)
55#include "chromeos/chromeos_switches.h"
56#endif
57
[email protected]2b07b8412009-11-25 15:26:3458#if defined(OS_WIN)
[email protected]2b07b8412009-11-25 15:26:3459#include <initguid.h>
[email protected]3ea1b182013-02-08 22:38:4160#include "base/logging_win.h"
[email protected]2b07b8412009-11-25 15:26:3461#endif
initial.commit09911bf2008-07-26 23:55:2962
[email protected]ab7ee5b2011-03-01 22:24:1463namespace {
64
initial.commit09911bf2008-07-26 23:55:2965// When true, this means that error dialogs should not be shown.
[email protected]ab7ee5b2011-03-01 22:24:1466bool dialogs_are_suppressed_ = false;
initial.commit09911bf2008-07-26 23:55:2967
68// This should be true for exactly the period between the end of
69// InitChromeLogging() and the beginning of CleanupChromeLogging().
[email protected]ab7ee5b2011-03-01 22:24:1470bool chrome_logging_initialized_ = false;
initial.commit09911bf2008-07-26 23:55:2971
[email protected]4a6d74152011-09-26 20:42:3072// Set if we called InitChromeLogging() but failed to initialize.
[email protected]ab7ee5b2011-03-01 22:24:1473bool chrome_logging_failed_ = false;
[email protected]7109dc32011-02-02 22:58:2974
[email protected]30f547c2010-08-04 01:00:0175// This should be true for exactly the period between the end of
76// InitChromeLogging() and the beginning of CleanupChromeLogging().
[email protected]ab7ee5b2011-03-01 22:24:1477bool chrome_logging_redirected_ = false;
[email protected]30f547c2010-08-04 01:00:0178
[email protected]2b07b8412009-11-25 15:26:3479#if defined(OS_WIN)
80// {7FE69228-633E-4f06-80C1-527FEA23E3A7}
[email protected]ab7ee5b2011-03-01 22:24:1481const GUID kChromeTraceProviderName = {
[email protected]162ac0f2010-11-04 15:50:4982 0x7fe69228, 0x633e, 0x4f06,
83 { 0x80, 0xc1, 0x52, 0x7f, 0xea, 0x23, 0xe3, 0xa7 } };
[email protected]2b07b8412009-11-25 15:26:3484#endif
85
initial.commit09911bf2008-07-26 23:55:2986// Assertion handler for logging errors that occur when dialogs are
87// silenced. To record a new error, pass the log string associated
88// with that error in the str parameter.
[email protected]0eb9f4342008-11-21 18:48:5289MSVC_DISABLE_OPTIMIZE();
[email protected]ab7ee5b2011-03-01 22:24:1490void SilentRuntimeAssertHandler(const std::string& str) {
[email protected]58580352010-10-26 04:07:5091 base::debug::BreakDebugger();
initial.commit09911bf2008-07-26 23:55:2992}
[email protected]ab7ee5b2011-03-01 22:24:1493void SilentRuntimeReportHandler(const std::string& str) {
[email protected]6cc67d7f2009-02-12 06:48:2494}
[email protected]ab7ee5b2011-03-01 22:24:1495#if defined(OS_WIN)
96// Handler to silently dump the current process when there is an assert in
97// chrome.
98void DumpProcessAssertHandler(const std::string& str) {
[email protected]fe69aa12013-02-01 03:37:2799 logging::DumpWithoutCrashing();
[email protected]ab7ee5b2011-03-01 22:24:14100}
101#endif // OS_WIN
[email protected]0eb9f4342008-11-21 18:48:52102MSVC_ENABLE_OPTIMIZE();
initial.commit09911bf2008-07-26 23:55:29103
104// Suppresses error/assertion dialogs and enables the logging of
105// those errors into silenced_errors_.
[email protected]ab7ee5b2011-03-01 22:24:14106void SuppressDialogs() {
initial.commit09911bf2008-07-26 23:55:29107 if (dialogs_are_suppressed_)
108 return;
109
110 logging::SetLogAssertHandler(SilentRuntimeAssertHandler);
[email protected]6cc67d7f2009-02-12 06:48:24111 logging::SetLogReportHandler(SilentRuntimeReportHandler);
initial.commit09911bf2008-07-26 23:55:29112
[email protected]ec657802008-11-07 20:05:39113#if defined(OS_WIN)
initial.commit09911bf2008-07-26 23:55:29114 UINT new_flags = SEM_FAILCRITICALERRORS |
115 SEM_NOGPFAULTERRORBOX |
116 SEM_NOOPENFILEERRORBOX;
117
118 // Preserve existing error mode, as discussed at http://t/dmea
119 UINT existing_flags = SetErrorMode(new_flags);
120 SetErrorMode(existing_flags | new_flags);
[email protected]ec657802008-11-07 20:05:39121#endif
initial.commit09911bf2008-07-26 23:55:29122
123 dialogs_are_suppressed_ = true;
124}
125
[email protected]ab7ee5b2011-03-01 22:24:14126} // anonymous namespace
127
initial.commit09911bf2008-07-26 23:55:29128namespace logging {
129
[email protected]77ee1b12010-06-14 16:21:30130LoggingDestination DetermineLogMode(const CommandLine& command_line) {
initial.commit09911bf2008-07-26 23:55:29131 // only use OutputDebugString in debug mode
132#ifdef NDEBUG
133 bool enable_logging = false;
[email protected]b7e0a2a2009-10-13 02:07:25134 const char *kInvertLoggingSwitch = switches::kEnableLogging;
initial.commit09911bf2008-07-26 23:55:29135 const logging::LoggingDestination kDefaultLoggingMode =
136 logging::LOG_ONLY_TO_FILE;
137#else
138 bool enable_logging = true;
[email protected]b7e0a2a2009-10-13 02:07:25139 const char *kInvertLoggingSwitch = switches::kDisableLogging;
initial.commit09911bf2008-07-26 23:55:29140 const logging::LoggingDestination kDefaultLoggingMode =
141 logging::LOG_TO_BOTH_FILE_AND_SYSTEM_DEBUG_LOG;
142#endif
143
144 if (command_line.HasSwitch(kInvertLoggingSwitch))
145 enable_logging = !enable_logging;
146
147 logging::LoggingDestination log_mode;
148 if (enable_logging) {
[email protected]3bba9582009-08-05 01:29:12149 // Let --enable-logging=stderr force only stderr, particularly useful for
150 // non-debug builds where otherwise you can't get logs to stderr at all.
[email protected]c4e52f0d2009-11-06 19:55:16151 if (command_line.GetSwitchValueASCII(switches::kEnableLogging) == "stderr")
[email protected]3bba9582009-08-05 01:29:12152 log_mode = logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG;
153 else
154 log_mode = kDefaultLoggingMode;
initial.commit09911bf2008-07-26 23:55:29155 } else {
156 log_mode = logging::LOG_NONE;
157 }
[email protected]77ee1b12010-06-14 16:21:30158 return log_mode;
159}
initial.commit09911bf2008-07-26 23:55:29160
[email protected]77ee1b12010-06-14 16:21:30161#if defined(OS_CHROMEOS)
[email protected]c7d5da992010-10-28 00:20:21162namespace {
[email protected]a7329162013-02-07 19:21:48163base::FilePath SetUpSymlinkIfNeeded(const base::FilePath& symlink_path,
164 bool new_log) {
[email protected]f25b33a2010-10-28 20:15:51165 DCHECK(!symlink_path.empty());
166
[email protected]c7d5da992010-10-28 00:20:21167 // If not starting a new log, then just log through the existing
168 // symlink, but if the symlink doesn't exist, create it. If
169 // starting a new log, then delete the old symlink and make a new
170 // one to a fresh log file.
[email protected]a7329162013-02-07 19:21:48171 base::FilePath target_path;
[email protected]0750b1442010-11-02 21:59:37172 bool symlink_exists = file_util::PathExists(symlink_path);
173 if (new_log || !symlink_exists) {
[email protected]c7d5da992010-10-28 00:20:21174 target_path = GenerateTimestampedName(symlink_path, base::Time::Now());
175
176 // We don't care if the unlink fails; we're going to continue anyway.
[email protected]723571a2010-12-03 17:37:54177 if (::unlink(symlink_path.value().c_str()) == -1) {
[email protected]0750b1442010-11-02 21:59:37178 if (symlink_exists) // only warn if we might expect it to succeed.
[email protected]26f025e2011-10-28 22:49:27179 DPLOG(WARNING) << "Unable to unlink " << symlink_path.value();
[email protected]c7d5da992010-10-28 00:20:21180 }
[email protected]723571a2010-12-03 17:37:54181 if (!file_util::CreateSymbolicLink(target_path, symlink_path)) {
[email protected]26f025e2011-10-28 22:49:27182 DPLOG(ERROR) << "Unable to create symlink " << symlink_path.value()
183 << " pointing at " << target_path.value();
[email protected]c7d5da992010-10-28 00:20:21184 }
185 } else {
[email protected]723571a2010-12-03 17:37:54186 if (!file_util::ReadSymbolicLink(symlink_path, &target_path))
[email protected]26f025e2011-10-28 22:49:27187 DPLOG(ERROR) << "Unable to read symlink " << symlink_path.value();
[email protected]c7d5da992010-10-28 00:20:21188 }
189 return target_path;
190}
191
[email protected]a7329162013-02-07 19:21:48192void RemoveSymlinkAndLog(const base::FilePath& link_path,
193 const base::FilePath& target_path) {
[email protected]c7d5da992010-10-28 00:20:21194 if (::unlink(link_path.value().c_str()) == -1)
[email protected]26f025e2011-10-28 22:49:27195 DPLOG(WARNING) << "Unable to unlink symlink " << link_path.value();
[email protected]c7d5da992010-10-28 00:20:21196 if (::unlink(target_path.value().c_str()) == -1)
[email protected]26f025e2011-10-28 22:49:27197 DPLOG(WARNING) << "Unable to unlink log file " << target_path.value();
[email protected]c7d5da992010-10-28 00:20:21198}
199
200} // anonymous namespace
201
[email protected]a7329162013-02-07 19:21:48202base::FilePath GetSessionLogFile(const CommandLine& command_line) {
203 base::FilePath log_dir;
[email protected]0750b1442010-11-02 21:59:37204 std::string log_dir_str;
205 scoped_ptr<base::Environment> env(base::Environment::Create());
206 if (env->GetVar(env_vars::kSessionLogDir, &log_dir_str) &&
207 !log_dir_str.empty()) {
[email protected]a7329162013-02-07 19:21:48208 log_dir = base::FilePath(log_dir_str);
[email protected]0750b1442010-11-02 21:59:37209 } else {
210 PathService::Get(chrome::DIR_USER_DATA, &log_dir);
[email protected]a7329162013-02-07 19:21:48211 base::FilePath login_profile =
[email protected]931d1042013-04-05 17:50:44212 command_line.GetSwitchValuePath(chromeos::switches::kLoginProfile);
[email protected]0750b1442010-11-02 21:59:37213 log_dir = log_dir.Append(login_profile);
214 }
215 return log_dir.Append(GetLogFileName().BaseName());
216}
217
218void RedirectChromeLogging(const CommandLine& command_line) {
[email protected]30f547c2010-08-04 01:00:01219 DCHECK(!chrome_logging_redirected_) <<
220 "Attempted to redirect logging when it was already initialized.";
[email protected]0750b1442010-11-02 21:59:37221
222 // Redirect logs to the session log directory, if set. Otherwise
223 // defaults to the profile dir.
[email protected]a7329162013-02-07 19:21:48224 base::FilePath log_path = GetSessionLogFile(command_line);
[email protected]c7d5da992010-10-28 00:20:21225
[email protected]61f93212011-01-24 14:37:08226 // Creating symlink causes us to do blocking IO on UI thread.
227 // Temporarily allow it until we fix http://crbug.com/61143
228 base::ThreadRestrictions::ScopedAllowIO allow_io;
[email protected]c7d5da992010-10-28 00:20:21229 // Always force a new symlink when redirecting.
[email protected]a7329162013-02-07 19:21:48230 base::FilePath target_path = SetUpSymlinkIfNeeded(log_path, true);
[email protected]c7d5da992010-10-28 00:20:21231
[email protected]7c10f7552011-01-11 01:03:36232 logging::DcheckState dcheck_state =
233 command_line.HasSwitch(switches::kEnableDCHECK) ?
234 logging::ENABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS :
235 logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS;
236
[email protected]c7d5da992010-10-28 00:20:21237 // ChromeOS always logs through the symlink, so it shouldn't be
238 // deleted if it already exists.
239 if (!InitLogging(log_path.value().c_str(),
240 DetermineLogMode(command_line),
241 logging::LOCK_LOG_FILE,
[email protected]7c10f7552011-01-11 01:03:36242 logging::APPEND_TO_OLD_LOG_FILE,
243 dcheck_state)) {
[email protected]26f025e2011-10-28 22:49:27244 DLOG(ERROR) << "Unable to initialize logging to " << log_path.value();
[email protected]c7d5da992010-10-28 00:20:21245 RemoveSymlinkAndLog(log_path, target_path);
246 } else {
247 chrome_logging_redirected_ = true;
248 }
[email protected]77ee1b12010-06-14 16:21:30249}
[email protected]0750b1442010-11-02 21:59:37250
[email protected]85271192011-05-10 20:38:25251#endif // OS_CHROMEOS
[email protected]77ee1b12010-06-14 16:21:30252
253void InitChromeLogging(const CommandLine& command_line,
254 OldFileDeletionState delete_old_log_file) {
255 DCHECK(!chrome_logging_initialized_) <<
256 "Attempted to initialize logging when it was already initialized.";
257
[email protected]4a100992011-06-14 18:22:46258 LoggingDestination logging_dest = DetermineLogMode(command_line);
[email protected]d64ea42172012-09-14 05:43:59259 LogLockingState log_locking_state = LOCK_LOG_FILE;
[email protected]a7329162013-02-07 19:21:48260 base::FilePath log_path;
[email protected]4a100992011-06-14 18:22:46261#if defined(OS_CHROMEOS)
[email protected]a7329162013-02-07 19:21:48262 base::FilePath target_path;
[email protected]4a100992011-06-14 18:22:46263#endif
[email protected]77ee1b12010-06-14 16:21:30264
[email protected]4a100992011-06-14 18:22:46265 // Don't resolve the log path unless we need to. Otherwise we leave an open
266 // ALPC handle after sandbox lockdown on Windows.
267 if (logging_dest == LOG_ONLY_TO_FILE ||
268 logging_dest == LOG_TO_BOTH_FILE_AND_SYSTEM_DEBUG_LOG) {
269 log_path = GetLogFileName();
[email protected]c7d5da992010-10-28 00:20:21270
[email protected]77ee1b12010-06-14 16:21:30271#if defined(OS_CHROMEOS)
[email protected]4a100992011-06-14 18:22:46272 // For BWSI (Incognito) logins, we want to put the logs in the user
273 // profile directory that is created for the temporary session instead
274 // of in the system log directory, for privacy reasons.
[email protected]931d1042013-04-05 17:50:44275 if (command_line.HasSwitch(chromeos::switches::kGuestSession))
[email protected]4a100992011-06-14 18:22:46276 log_path = GetSessionLogFile(command_line);
[email protected]0750b1442010-11-02 21:59:37277
[email protected]4a100992011-06-14 18:22:46278 // On ChromeOS we log to the symlink. We force creation of a new
279 // symlink if we've been asked to delete the old log, since that
280 // indicates the start of a new session.
281 target_path = SetUpSymlinkIfNeeded(
282 log_path, delete_old_log_file == logging::DELETE_OLD_LOG_FILE);
[email protected]c7d5da992010-10-28 00:20:21283
[email protected]4a100992011-06-14 18:22:46284 // Because ChromeOS manages the move to a new session by redirecting
285 // the link, it shouldn't remove the old file in the logging code,
286 // since that will remove the newly created link instead.
287 delete_old_log_file = logging::APPEND_TO_OLD_LOG_FILE;
[email protected]77ee1b12010-06-14 16:21:30288#endif
[email protected]d64ea42172012-09-14 05:43:59289 } else {
290 log_locking_state = DONT_LOCK_LOG_FILE;
[email protected]4a100992011-06-14 18:22:46291 }
[email protected]77ee1b12010-06-14 16:21:30292
[email protected]7c10f7552011-01-11 01:03:36293 logging::DcheckState dcheck_state =
294 command_line.HasSwitch(switches::kEnableDCHECK) ?
295 logging::ENABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS :
296 logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS;
297
[email protected]c7d5da992010-10-28 00:20:21298 bool success = InitLogging(log_path.value().c_str(),
[email protected]4a100992011-06-14 18:22:46299 logging_dest,
[email protected]d64ea42172012-09-14 05:43:59300 log_locking_state,
[email protected]7c10f7552011-01-11 01:03:36301 delete_old_log_file,
302 dcheck_state);
[email protected]c7d5da992010-10-28 00:20:21303
304#if defined(OS_CHROMEOS)
305 if (!success) {
[email protected]26f025e2011-10-28 22:49:27306 DPLOG(ERROR) << "Unable to initialize logging to " << log_path.value()
[email protected]c7d5da992010-10-28 00:20:21307 << " (which should be a link to " << target_path.value() << ")";
308 RemoveSymlinkAndLog(log_path, target_path);
[email protected]7109dc32011-02-02 22:58:29309 chrome_logging_failed_ = true;
[email protected]c7d5da992010-10-28 00:20:21310 return;
311 }
312#else
313 if (!success) {
[email protected]26f025e2011-10-28 22:49:27314 DPLOG(ERROR) << "Unable to initialize logging to " << log_path.value();
[email protected]7109dc32011-02-02 22:58:29315 chrome_logging_failed_ = true;
[email protected]c7d5da992010-10-28 00:20:21316 return;
317 }
318#endif
initial.commit09911bf2008-07-26 23:55:29319
[email protected]81e0a852010-08-17 00:38:12320 // Default to showing error dialogs.
321 if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoErrorDialogs))
322 logging::SetShowErrorDialogs(true);
323
initial.commit09911bf2008-07-26 23:55:29324 // we want process and thread IDs because we have a lot of things running
[email protected]c7d5da992010-10-28 00:20:21325 logging::SetLogItems(true, // enable_process_id
326 true, // enable_thread_id
[email protected]51f5a60c2012-09-01 06:07:55327 true, // enable_timestamp
328 false); // enable_tickcount
initial.commit09911bf2008-07-26 23:55:29329
330 // We call running in unattended mode "headless", and allow
331 // headless mode to be configured either by the Environment
332 // Variable or by the Command Line Switch. This is for
333 // automated test purposes.
[email protected]76b90d312010-08-03 03:00:50334 scoped_ptr<base::Environment> env(base::Environment::Create());
[email protected]9432ade2010-08-04 23:43:20335 if (env->HasVar(env_vars::kHeadless) ||
initial.commit09911bf2008-07-26 23:55:29336 command_line.HasSwitch(switches::kNoErrorDialogs))
337 SuppressDialogs();
338
[email protected]3deeb6b32010-10-05 21:53:52339 // Use a minimum log level if the command line asks for one,
340 // otherwise leave it at the default level (INFO).
341 if (command_line.HasSwitch(switches::kLoggingLevel)) {
342 std::string log_level = command_line.GetSwitchValueASCII(
343 switches::kLoggingLevel);
344 int level = 0;
345 if (base::StringToInt(log_level, &level) &&
346 level >= 0 && level < LOG_NUM_SEVERITIES) {
[email protected]bb5185c52008-08-29 19:51:06347 logging::SetMinLogLevel(level);
[email protected]3deeb6b32010-10-05 21:53:52348 } else {
[email protected]26f025e2011-10-28 22:49:27349 DLOG(WARNING) << "Bad log level: " << log_level;
[email protected]3deeb6b32010-10-05 21:53:52350 }
[email protected]bb5185c52008-08-29 19:51:06351 }
352
[email protected]2b07b8412009-11-25 15:26:34353#if defined(OS_WIN)
354 // Enable trace control and transport through event tracing for Windows.
[email protected]b650bf42012-03-15 01:02:24355 logging::LogEventProvider::Initialize(kChromeTraceProviderName);
[email protected]2b07b8412009-11-25 15:26:34356#endif
357
[email protected]ab7ee5b2011-03-01 22:24:14358#ifdef NDEBUG
359 if (command_line.HasSwitch(switches::kSilentDumpOnDCHECK) &&
360 command_line.HasSwitch(switches::kEnableDCHECK)) {
361#if defined(OS_WIN)
362 logging::SetLogReportHandler(DumpProcessAssertHandler);
363#endif
364 }
365#endif // NDEBUG
366
initial.commit09911bf2008-07-26 23:55:29367 chrome_logging_initialized_ = true;
368}
369
370// This is a no-op, but we'll keep it around in case
371// we need to do more cleanup in the future.
372void CleanupChromeLogging() {
[email protected]7109dc32011-02-02 22:58:29373 if (chrome_logging_failed_)
374 return; // We failed to initiailize logging, no cleanup.
375
initial.commit09911bf2008-07-26 23:55:29376 DCHECK(chrome_logging_initialized_) <<
377 "Attempted to clean up logging when it wasn't initialized.";
378
379 CloseLogFile();
380
381 chrome_logging_initialized_ = false;
[email protected]30f547c2010-08-04 01:00:01382 chrome_logging_redirected_ = false;
initial.commit09911bf2008-07-26 23:55:29383}
384
[email protected]a7329162013-02-07 19:21:48385base::FilePath GetLogFileName() {
[email protected]c83dd912010-04-06 18:50:51386 std::string filename;
[email protected]76b90d312010-08-03 03:00:50387 scoped_ptr<base::Environment> env(base::Environment::Create());
[email protected]3ba7e082010-08-07 02:57:59388 if (env->GetVar(env_vars::kLogFileName, &filename) && !filename.empty()) {
[email protected]c83dd912010-04-06 18:50:51389#if defined(OS_WIN)
[email protected]47e870b2013-02-24 21:14:53390 return base::FilePath(UTF8ToWide(filename));
[email protected]c83dd912010-04-06 18:50:51391#elif defined(OS_POSIX)
[email protected]a7329162013-02-07 19:21:48392 return base::FilePath(filename);
[email protected]c83dd912010-04-06 18:50:51393#endif
394 }
initial.commit09911bf2008-07-26 23:55:29395
[email protected]a7329162013-02-07 19:21:48396 const base::FilePath log_filename(FILE_PATH_LITERAL("chrome_debug.log"));
397 base::FilePath log_path;
initial.commit09911bf2008-07-26 23:55:29398
399 if (PathService::Get(chrome::DIR_LOGS, &log_path)) {
[email protected]73e23482009-08-13 00:26:58400 log_path = log_path.Append(log_filename);
initial.commit09911bf2008-07-26 23:55:29401 return log_path;
402 } else {
403 // error with path service, just use some default file somewhere
404 return log_filename;
405 }
406}
407
408bool DialogsAreSuppressed() {
409 return dialogs_are_suppressed_;
410}
411
412size_t GetFatalAssertions(AssertionList* assertions) {
413 // In this function, we don't assume that assertions is non-null, so
414 // that if you just want an assertion count, you can pass in NULL.
415 if (assertions)
416 assertions->clear();
417 size_t assertion_count = 0;
418
419 std::ifstream log_file;
[email protected]73e23482009-08-13 00:26:58420 log_file.open(GetLogFileName().value().c_str());
initial.commit09911bf2008-07-26 23:55:29421 if (!log_file.is_open())
422 return 0;
423
424 std::string utf8_line;
425 std::wstring wide_line;
[email protected]4a3dab22009-11-11 17:36:50426 while (!log_file.eof()) {
initial.commit09911bf2008-07-26 23:55:29427 getline(log_file, utf8_line);
428 if (utf8_line.find(":FATAL:") != std::string::npos) {
[email protected]47e870b2013-02-24 21:14:53429 wide_line = UTF8ToWide(utf8_line);
initial.commit09911bf2008-07-26 23:55:29430 if (assertions)
431 assertions->push_back(wide_line);
432 ++assertion_count;
433 }
434 }
435 log_file.close();
436
437 return assertion_count;
438}
439
[email protected]a7329162013-02-07 19:21:48440base::FilePath GenerateTimestampedName(const base::FilePath& base_path,
441 base::Time timestamp) {
[email protected]395a0392012-04-12 15:35:03442 base::Time::Exploded time_deets;
443 timestamp.LocalExplode(&time_deets);
444 std::string suffix = base::StringPrintf("_%02d%02d%02d-%02d%02d%02d",
445 time_deets.year,
446 time_deets.month,
447 time_deets.day_of_month,
448 time_deets.hour,
449 time_deets.minute,
450 time_deets.second);
451 return base_path.InsertBeforeExtensionASCII(suffix);
452}
453
[email protected]c83dd912010-04-06 18:50:51454} // namespace logging