The Tor Browser / file comparison
comparison: security/sandbox/chromium/base/logging_win.cc
security/sandbox/chromium/base/logging_win.cc
- branch
- TOR_BUG_9701
- changeset 14
- 925c144e1f1f
equal
deleted
inserted
replaced
| -1:000000000000 | 0:a12c6491d8f1 |
|---|---|
| 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/logging_win.h" | |
| 6 #include "base/memory/singleton.h" | |
| 7 #include <initguid.h> // NOLINT | |
| 8 | |
| 9 namespace logging { | |
| 10 | |
| 11 using base::win::EtwEventLevel; | |
| 12 using base::win::EtwMofEvent; | |
| 13 | |
| 14 DEFINE_GUID(kLogEventId, | |
| 15 0x7fe69228, 0x633e, 0x4f06, 0x80, 0xc1, 0x52, 0x7f, 0xea, 0x23, 0xe3, 0xa7); | |
| 16 | |
| 17 LogEventProvider::LogEventProvider() : old_log_level_(LOG_NONE) { | |
| 18 } | |
| 19 | |
| 20 LogEventProvider* LogEventProvider::GetInstance() { | |
| 21 return Singleton<LogEventProvider, | |
| 22 StaticMemorySingletonTraits<LogEventProvider> >::get(); | |
| 23 } | |
| 24 | |
| 25 bool LogEventProvider::LogMessage(logging::LogSeverity severity, | |
| 26 const char* file, int line, size_t message_start, | |
| 27 const std::string& message) { | |
| 28 EtwEventLevel level = TRACE_LEVEL_NONE; | |
| 29 | |
| 30 // Convert the log severity to the most appropriate ETW trace level. | |
| 31 if (severity >= 0) { | |
| 32 switch (severity) { | |
| 33 case LOG_INFO: | |
| 34 level = TRACE_LEVEL_INFORMATION; | |
| 35 break; | |
| 36 case LOG_WARNING: | |
| 37 level = TRACE_LEVEL_WARNING; | |
| 38 break; | |
| 39 case LOG_ERROR: | |
| 40 case LOG_ERROR_REPORT: | |
| 41 level = TRACE_LEVEL_ERROR; | |
| 42 break; | |
| 43 case LOG_FATAL: | |
| 44 level = TRACE_LEVEL_FATAL; | |
| 45 break; | |
| 46 } | |
| 47 } else { // severity < 0 is VLOG verbosity levels. | |
| 48 level = TRACE_LEVEL_INFORMATION - severity; | |
| 49 } | |
| 50 | |
| 51 // Bail if we're not logging, not at that level, | |
| 52 // or if we're post-atexit handling. | |
| 53 LogEventProvider* provider = LogEventProvider::GetInstance(); | |
| 54 if (provider == NULL || level > provider->enable_level()) | |
| 55 return false; | |
| 56 | |
| 57 // And now log the event. | |
| 58 if (provider->enable_flags() & ENABLE_LOG_MESSAGE_ONLY) { | |
| 59 EtwMofEvent<1> event(kLogEventId, LOG_MESSAGE, level); | |
| 60 event.SetField(0, message.length() + 1 - message_start, | |
| 61 message.c_str() + message_start); | |
| 62 | |
| 63 provider->Log(event.get()); | |
| 64 } else { | |
| 65 const size_t kMaxBacktraceDepth = 32; | |
| 66 void* backtrace[kMaxBacktraceDepth]; | |
| 67 DWORD depth = 0; | |
| 68 | |
| 69 // Capture a stack trace if one is requested. | |
| 70 // requested per our enable flags. | |
| 71 if (provider->enable_flags() & ENABLE_STACK_TRACE_CAPTURE) | |
| 72 depth = CaptureStackBackTrace(2, kMaxBacktraceDepth, backtrace, NULL); | |
| 73 | |
| 74 EtwMofEvent<5> event(kLogEventId, LOG_MESSAGE_FULL, level); | |
| 75 if (file == NULL) | |
| 76 file = ""; | |
| 77 | |
| 78 // Add the stack trace. | |
| 79 event.SetField(0, sizeof(depth), &depth); | |
| 80 event.SetField(1, sizeof(backtrace[0]) * depth, &backtrace); | |
| 81 // The line. | |
| 82 event.SetField(2, sizeof(line), &line); | |
| 83 // The file. | |
| 84 event.SetField(3, strlen(file) + 1, file); | |
| 85 // And finally the message. | |
| 86 event.SetField(4, message.length() + 1 - message_start, | |
| 87 message.c_str() + message_start); | |
| 88 | |
| 89 provider->Log(event.get()); | |
| 90 } | |
| 91 | |
| 92 // Don't increase verbosity in other log destinations. | |
| 93 if (severity < provider->old_log_level_) | |
| 94 return true; | |
| 95 | |
| 96 return false; | |
| 97 } | |
| 98 | |
| 99 void LogEventProvider::Initialize(const GUID& provider_name) { | |
| 100 LogEventProvider* provider = LogEventProvider::GetInstance(); | |
| 101 | |
| 102 provider->set_provider_name(provider_name); | |
| 103 provider->Register(); | |
| 104 | |
| 105 // Register our message handler with logging. | |
| 106 SetLogMessageHandler(LogMessage); | |
| 107 } | |
| 108 | |
| 109 void LogEventProvider::Uninitialize() { | |
| 110 LogEventProvider::GetInstance()->Unregister(); | |
| 111 } | |
| 112 | |
| 113 void LogEventProvider::OnEventsEnabled() { | |
| 114 // Grab the old log level so we can restore it later. | |
| 115 old_log_level_ = GetMinLogLevel(); | |
| 116 | |
| 117 // Convert the new trace level to a logging severity | |
| 118 // and enable logging at that level. | |
| 119 EtwEventLevel level = enable_level(); | |
| 120 if (level == TRACE_LEVEL_NONE || level == TRACE_LEVEL_FATAL) { | |
| 121 SetMinLogLevel(LOG_FATAL); | |
| 122 } else if (level == TRACE_LEVEL_ERROR) { | |
| 123 SetMinLogLevel(LOG_ERROR); | |
| 124 } else if (level == TRACE_LEVEL_WARNING) { | |
| 125 SetMinLogLevel(LOG_WARNING); | |
| 126 } else if (level == TRACE_LEVEL_INFORMATION) { | |
| 127 SetMinLogLevel(LOG_INFO); | |
| 128 } else if (level >= TRACE_LEVEL_VERBOSE) { | |
| 129 // Above INFO, we enable verbose levels with negative severities. | |
| 130 SetMinLogLevel(TRACE_LEVEL_INFORMATION - level); | |
| 131 } | |
| 132 } | |
| 133 | |
| 134 void LogEventProvider::OnEventsDisabled() { | |
| 135 // Restore the old log level. | |
| 136 SetMinLogLevel(old_log_level_); | |
| 137 } | |
| 138 | |
| 139 } // namespace logging |
