Mirror syncfs log to console and WebUI, with LogSeverity support.

chrome/browser/sync_file_system/logger.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/sync_file_system/logger.h"
 
+#include "base/file_util.h"
 #include "base/lazy_instance.h"
+#include "base/location.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/google_apis/event_logger.h"
 
 namespace sync_file_system {
 namespace util {
 namespace {
 
 static base::LazyInstance<google_apis::EventLogger> g_logger =
     LAZY_INSTANCE_INITIALIZER;
 
+std::string LogSeverityToString(logging::LogSeverity level) {
+  switch (level) {
+    case logging::LOG_ERROR:
+      return "ERROR";
+    case logging::LOG_WARNING:
+      return "WARNING";
+    case logging::LOG_INFO:
+      return "INFO";
+  }
+
+  NOTREACHED();
+  return "Unknown Log Severity";
+}
+
+void LogToConsole(logging::LogSeverity level, const std::string& log_event) {
+  switch (level) {
+    case logging::LOG_ERROR:
+      RAW_LOG(ERROR, log_event.c_str());
+      return;
+    case logging::LOG_WARNING:
+      RAW_LOG(WARNING, log_event.c_str());
+      return;
+    case logging::LOG_INFO:
+      RAW_LOG(INFO, log_event.c_str());
+      return;
+    }
+
+  LOG(ERROR) << "LogToConsole() missing case for LogSeverity=" << level;
+  NOTREACHED();
+}
+
 }  // namespace
 
-void Log(const char* format, ...) {
+void ClearLog() {
+  g_logger.Pointer()->SetHistorySize(google_apis::kDefaultHistorySize);
+}
+
+void Log(tracked_objects::Location location,
+         logging::LogSeverity severity,
+         const char* format,
+         ...) {
+  // Ignore log if level severity is not high enough.
+  if (severity < logging::GetMinLogLevel())
+    return;
+
   std::string what;
 
   va_list args;
   va_start(args, format);
   base::StringAppendV(&what, format, args);
   va_end(args);
 
+  // Use same output format as normal console logger.
+  base::FilePath path(FILE_PATH_LITERAL(location.file_name()));

[tzik, 2013/05/24 04:08:32]

FILE_PATH_LITERAL is only for a literal. This will hit a compile error on
windows.

[calvinlo, 2013/05/24 05:12:43]

Thanks for Hiroki for pointing out that I can probably use
base::FilePath::FromUTF8Unsafe(location.file_name());

+  std::string log_output = base::StringPrintf(
+      "[%s: %s(%d)] %s",
+      LogSeverityToString(severity).c_str(),
+      path.BaseName().AsUTF8Unsafe().c_str(),
+      location.line_number(),
+      what.c_str());
+
+  // Log to WebUI.
   // On thread-safety: LazyInstance guarantees thread-safety for the object
   // creation. EventLogger::Log() internally maintains the lock.
   google_apis::EventLogger* ptr = g_logger.Pointer();
-  ptr->Log("%s", what.c_str());
+  ptr->Log("%s", log_output.c_str());
+
+  // Log to console.
+  LogToConsole(severity, log_output);

[tzik, 2013/05/24 04:08:32]

Can we use RowLog instead? And then can we drop LogToConsole?

[calvinlo, 2013/05/24 05:12:43]

I tried this originally but I couldn't figure out a good way to map from
logging::LogSeverity severity back to the macros INFO, WARNING, ERROR. i.e. how
to do 
RAW_LOG(severity, message) without the switch from LogToConsole();

I could move the LOG(severity) statement back into the macro but then I'd have
to keep the StringPrintf in the macro too.

Is there a third solution?

[tzik, 2013/05/24 11:17:38]

Just like below seems to work:
logging::RawLog(severity, log_output.c_str());

 }
 
 std::vector<google_apis::EventLogger::Event> GetLogHistory() {
   google_apis::EventLogger* ptr = g_logger.Pointer();
   return ptr->GetHistory();
 }
 
 }  // namespace util
 }  // namespace sync_file_system