| // Copyright 2015 Google Inc. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "cobalt/base/log_message_handler.h" |
| |
| #include "base/threading/thread_restrictions.h" |
| |
| namespace base { |
| |
| namespace { |
| // Checks whether this thread allows Singleton access. Some threads |
| // (e.g. detached threads, non-joinable threads) do not allow Singleton |
| // access, which means we cannot access our |LogMessageHandler| instance, |
| // nor even call |MessageLoop::current|. |
| bool DoesThreadAllowSingletons() { |
| return ThreadRestrictions::GetSingletonAllowed(); |
| } |
| } // namespace |
| |
| LogMessageHandler* LogMessageHandler::GetInstance() { |
| return Singleton<LogMessageHandler, |
| StaticMemorySingletonTraits<LogMessageHandler> >::get(); |
| } |
| |
| LogMessageHandler::LogMessageHandler() { |
| // Create the lock used to allow thread-safe checking of the thread. |
| // Set the global log message handler to our static member function. |
| old_log_message_handler_ = logging::GetLogMessageHandler(); |
| logging::SetLogMessageHandler(OnLogMessage); |
| } |
| |
| LogMessageHandler::~LogMessageHandler() { |
| logging::SetLogMessageHandler(old_log_message_handler_); |
| } |
| |
| LogMessageHandler::CallbackId LogMessageHandler::AddCallback( |
| const OnLogMessageCallback& callback) { |
| AutoLock auto_lock(lock_); |
| const CallbackId callback_id = next_callback_id_++; |
| callbacks_[callback_id] = callback; |
| return callback_id; |
| } |
| |
| void LogMessageHandler::RemoveCallback(CallbackId callback_id) { |
| AutoLock auto_lock(lock_); |
| callbacks_.erase(callback_id); |
| } |
| |
| // static |
| bool LogMessageHandler::OnLogMessage(int severity, const char* file, int line, |
| size_t message_start, |
| const std::string& str) { |
| // If we are on a thread that doesn't support Singletons, we can't do |
| // anything. |
| if (!DoesThreadAllowSingletons()) { |
| return false; |
| } |
| |
| LogMessageHandler* instance = GetInstance(); |
| AutoLock auto_lock(instance->lock_); |
| |
| bool suppress = instance->suppress_log_output_; |
| for (CallbackMap::const_iterator it = instance->callbacks_.begin(); |
| it != instance->callbacks_.end(); ++it) { |
| if (it->second.Run(severity, file, line, message_start, str)) { |
| suppress = true; |
| } |
| } |
| |
| return suppress; |
| } |
| |
| void LogMessageHandler::SetSuppressLogOutput(bool suppress_log_output) { |
| suppress_log_output_ = suppress_log_output; |
| } |
| |
| bool LogMessageHandler::GetSuppressLogOutput() { return suppress_log_output_; } |
| |
| } // namespace base |