1 // Copyright (c) 2012 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 "remoting/host/plugin/host_log_handler.h" 6 7 #include "base/lazy_instance.h" 8 #include "remoting/base/logging.h" 9 #include "remoting/base/util.h" 10 #include "remoting/host/plugin/host_script_object.h" 11 12 namespace remoting { 13 14 // Records whether or not we have a scriptable object registered for logging. 15 // This is set inside the lock, but is read (in LogToUI) outside of a lock so 16 // that we don't needlessly slow down the system when we log. 17 static bool g_has_logging_scriptable_object = false; 18 19 // The lock that protects the logging globals. 20 static base::LazyInstance<base::Lock>::Leaky 21 g_logging_lock = LAZY_INSTANCE_INITIALIZER; 22 23 // The scriptable object that will display the log information to the user. 24 static HostNPScriptObject* g_logging_scriptable_object = NULL; 25 26 // The previously registered LogMessageHandler. If not NULL, we call this after 27 // we're doing processing the log message. 28 static logging::LogMessageHandlerFunction g_logging_old_handler = NULL; 29 30 // Set to true when we register our global log handler so that we don't try 31 // to register it twice. 32 static bool g_has_registered_log_handler = false; 33 34 // static 35 void HostLogHandler::RegisterLogMessageHandler() { 36 base::AutoLock lock(g_logging_lock.Get()); 37 38 if (g_has_registered_log_handler) 39 return; 40 41 HOST_LOG << "Registering global log handler"; 42 43 // Record previous handler so we can call it in a chain. 44 g_logging_old_handler = logging::GetLogMessageHandler(); 45 46 // Set up log message handler. 47 // This is not thread-safe so we need it within our lock. 48 // Note that this will not log anything until a scriptable object instance 49 // has been created to handle the log message display. 50 logging::SetLogMessageHandler(&LogToUI); 51 g_has_registered_log_handler = true; 52 } 53 54 // static 55 void HostLogHandler::RegisterLoggingScriptObject( 56 HostNPScriptObject* script_object) { 57 base::AutoLock lock(g_logging_lock.Get()); 58 59 VLOG(1) << "Registering log handler scriptable object"; 60 61 // Register this script object as the one that will handle all logging calls 62 // and display them to the user. 63 // If multiple plugins are run, then the last one registered will handle all 64 // logging for all instances. 65 g_logging_scriptable_object = script_object; 66 g_has_logging_scriptable_object = true; 67 } 68 69 // static 70 void HostLogHandler::UnregisterLoggingScriptObject( 71 HostNPScriptObject* script_object) { 72 base::AutoLock lock(g_logging_lock.Get()); 73 74 // Ignore unless we're the currently registered script object. 75 if (script_object != g_logging_scriptable_object) 76 return; 77 78 // Unregister this script object for logging. 79 g_has_logging_scriptable_object = false; 80 g_logging_scriptable_object = NULL; 81 82 VLOG(1) << "Unregistering log handler scriptable object"; 83 } 84 85 // static 86 bool HostLogHandler::LogToUI(int severity, const char* file, int line, 87 size_t message_start, 88 const std::string& str) { 89 // Note: We're reading |g_has_logging_scriptable_object| outside of a lock. 90 // This lockless read is done so that we don't needlessly slow down global 91 // logging with a lock for each log message. 92 // 93 // This lockless read is safe because: 94 // 95 // Misreading a false value (when it should be true) means that we'll simply 96 // skip processing a few log messages. 97 // 98 // Misreading a true value (when it should be false) means that we'll take 99 // the lock and check |g_logging_scriptable_object| unnecessarily. This is not 100 // problematic because we always set |g_logging_scriptable_object| inside a 101 // lock. 102 // 103 // Misreading an old cached value is also not problematic for the same 104 // reasons: a mis-read either skips a log message or causes us to take a lock 105 // unnecessarily. 106 if (g_has_logging_scriptable_object) { 107 base::AutoLock lock(g_logging_lock.Get()); 108 109 if (g_logging_scriptable_object) { 110 std::string message = remoting::GetTimestampString(); 111 message += (str.c_str() + message_start); 112 g_logging_scriptable_object->PostLogDebugInfo(message); 113 } 114 } 115 116 // Call the next log handler in the chain. 117 if (g_logging_old_handler) 118 return (g_logging_old_handler)(severity, file, line, message_start, str); 119 120 return false; 121 } 122 123 } // namespace remoting 124
