Allow multiple logging::LogMessage{Handler,Listener}s

remoting/host/native_messaging/log_message_handler.cc

Index: remoting/host/native_messaging/log_message_handler.cc
diff --git a/remoting/host/native_messaging/log_message_handler.cc b/remoting/host/native_messaging/log_message_handler.cc
index 70f744b87e87b1d5ddcd84c486a7b06c720dc715..62481fdd8663b6202d8099659592058d46e49a54 100644
--- a/remoting/host/native_messaging/log_message_handler.cc
+++ b/remoting/host/native_messaging/log_message_handler.cc
@@ -15,62 +15,51 @@
 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 =
+// Log message listener registration and deregistration is not thread-safe.
+// This lock must be held in order to set or restore a log message listener,
+// and when accessing the pointer to the LogMessageListener instance.
+base::LazyInstance<base::Lock>::Leaky g_log_message_listener_lock =
     LAZY_INSTANCE_INITIALIZER;
 
-// The singleton LogMessageHandler instance, or null if log messages are not
+// The singleton LogMessageListener 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;
+LogMessageListener* g_log_message_listener = nullptr;
 }  // namespace
 
-LogMessageHandler::LogMessageHandler(
-    const Delegate& delegate)
+LogMessageListener::LogMessageListener(const Delegate& delegate)
     : delegate_(delegate),
       suppress_logging_(false),
       caller_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_ptr_factory_(this) {
-  base::AutoLock lock(g_log_message_handler_lock.Get());
-  if (g_log_message_handler) {
-    LOG(FATAL) << "LogMessageHandler is already registered. Only one instance "
+  base::AutoLock lock(g_log_message_listener_lock.Get());
+  if (g_log_message_listener) {
+    LOG(FATAL) << "LogMessageListener 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;
+  g_log_message_listener = 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;
+LogMessageListener::~LogMessageListener() {
+  base::AutoLock lock(g_log_message_listener_lock.Get());
+  g_log_message_listener = 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);
+const char* LogMessageListener::kDebugMessageTypeName = "_debug_log";
+
+void LogMessageListener::OnMessage(logging::LogSeverity severity,
+                                   const char* file,
+                                   int line,
+                                   size_t message_start,
+                                   const std::string& str) {
+  base::AutoLock lock(g_log_message_listener_lock.Get());
+  if (g_log_message_listener) {
+    g_log_message_listener->PostLogMessageToCorrectThread(severity, file, line,
+                                                          message_start, str);
   }
-  return false;
 }
 
-void LogMessageHandler::PostLogMessageToCorrectThread(
+void LogMessageListener::PostLogMessageToCorrectThread(
     logging::LogSeverity severity,
     const char* file,
     int line,
@@ -90,18 +79,16 @@ void LogMessageHandler::PostLogMessageToCorrectThread(
   // 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::Bind(&LogMessageHandler::SendLogMessageToClient,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 severity, file, line, message_start, str));
+      FROM_HERE, base::Bind(&LogMessageListener::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) {
+void LogMessageListener::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";