1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "remoting/host/native_messaging/log_message_handler.h"
#include "base/functional/bind.h"
#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/strings/string_util.h"
#include "base/synchronization/lock.h"
#include "base/task/single_thread_task_runner.h"
#include "base/values.h"
namespace remoting {
namespace {
// Log message handler registration and deregistration is not thread-safe.
// This lock must be held in order to set or restore a log message handler,
// and when accessing the pointer to the LogMessageHandler instance.
base::LazyInstance<base::Lock>::Leaky g_log_message_handler_lock =
LAZY_INSTANCE_INITIALIZER;
// The singleton LogMessageHandler instance, or null if log messages are not
// being intercepted. It must be dereferenced and updated under the above lock.
LogMessageHandler* g_log_message_handler = nullptr;
} // namespace
LogMessageHandler::LogMessageHandler(const Delegate& delegate)
: delegate_(delegate),
suppress_logging_(false),
caller_task_runner_(base::SingleThreadTaskRunner::GetCurrentDefault()) {
base::AutoLock lock(g_log_message_handler_lock.Get());
if (g_log_message_handler) {
LOG(FATAL) << "LogMessageHandler is already registered. Only one instance "
<< "per process is allowed.";
}
previous_log_message_handler_ = logging::GetLogMessageHandler();
logging::SetLogMessageHandler(&LogMessageHandler::OnLogMessage);
g_log_message_handler = this;
}
LogMessageHandler::~LogMessageHandler() {
base::AutoLock lock(g_log_message_handler_lock.Get());
if (logging::GetLogMessageHandler() != &LogMessageHandler::OnLogMessage) {
LOG(FATAL) << "LogMessageHandler is not the top-most message handler. "
<< "Cannot unregister.";
}
logging::SetLogMessageHandler(previous_log_message_handler_);
g_log_message_handler = nullptr;
}
// static
const char* LogMessageHandler::kDebugMessageTypeName = "_debug_log";
// static
bool LogMessageHandler::OnLogMessage(logging::LogSeverity severity,
const char* file,
int line,
size_t message_start,
const std::string& str) {
base::AutoLock lock(g_log_message_handler_lock.Get());
if (g_log_message_handler) {
g_log_message_handler->PostLogMessageToCorrectThread(severity, file, line,
message_start, str);
}
return false;
}
void LogMessageHandler::PostLogMessageToCorrectThread(
logging::LogSeverity severity,
const char* file,
int line,
size_t message_start,
const std::string& str) {
if (caller_task_runner_->BelongsToCurrentThread()) {
// Don't process this message if we're already logging and on the caller
// thread. This guards against an infinite loop if any code called by this
// class logs something.
if (suppress_logging_) {
return;
}
if (log_synchronously_if_possible_) {
SendLogMessageToClient(severity, file, line, message_start, str);
return;
}
}
// This method is always called under the global lock, so post a task to
// handle the log message, even if we're already on the correct thread, unless
// it is explicitly configured not to do so. This allows the lock to be
// released quickly.
//
// Note that this means that LOG(FATAL) messages will be lost because the
// process will exit before the message is sent to the client.
caller_task_runner_->PostTask(
FROM_HERE, base::BindOnce(&LogMessageHandler::SendLogMessageToClient,
weak_ptr_factory_.GetWeakPtr(), severity, file,
line, message_start, str));
}
void LogMessageHandler::SendLogMessageToClient(logging::LogSeverity severity,
const char* file,
int line,
size_t message_start,
const std::string& str) {
suppress_logging_ = true;
std::string severity_string = "log";
switch (severity) {
case logging::LOGGING_WARNING:
severity_string = "warn";
break;
case logging::LOGGING_ERROR:
case logging::LOGGING_FATAL:
severity_string = "error";
break;
}
std::string message = str.substr(message_start);
base::TrimWhitespaceASCII(message, base::TRIM_ALL, &message);
base::Value::Dict dictionary;
dictionary.Set("type", kDebugMessageTypeName);
dictionary.Set("severity", severity_string);
dictionary.Set("message", message);
dictionary.Set("file", file);
dictionary.Set("line", line);
// Protect against this instance being torn down after the delegate is run.
base::WeakPtr<LogMessageHandler> self = weak_ptr_factory_.GetWeakPtr();
delegate_.Run(std::move(dictionary));
if (self) {
suppress_logging_ = false;
}
}
} // namespace remoting
|
