FLOG: Add examples/flog_viewer and always show MOJO_DLOG messages

services/flog/flog_logger_impl.cc

 // Copyright 2016 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 <iomanip>
+#include <iostream>
+
 #include "base/logging.h"
 #include "services/flog/flog_logger_impl.h"
 
 namespace mojo {
 namespace flog {
 
+namespace {
+
+struct AsMicroseconds {
+  explicit AsMicroseconds(uint64_t time_us) : time_us_(time_us) {}
+  uint64_t time_us_;
+};
+
+std::ostream& operator<<(std::ostream& os, AsMicroseconds value) {
+  return os << std::setfill('0') << std::setw(6) << value.time_us_ % 1000000ull;
+}
+
+struct AsLogLevel {
+  explicit AsLogLevel(uint32_t level) : level_(level) {}
+  uint32_t level_;
+};
+
+std::ostream& operator<<(std::ostream& os, AsLogLevel value) {
+  switch (value.level_) {
+    case MOJO_LOG_LEVEL_VERBOSE:
+      return os << "VERBOSE";
+    case MOJO_LOG_LEVEL_INFO:
+      return os << "INFO";
+    case MOJO_LOG_LEVEL_WARNING:
+      return os << "WARNING";
+    case MOJO_LOG_LEVEL_ERROR:
+      return os << "ERROR";
+    case MOJO_LOG_LEVEL_FATAL:
+      return os << "FATAL";
+    default:
+      return os << "UNKNOWN LEVEL " << value.level_;
+  }
+}
+
+}  // namespace
+
 // static
 std::shared_ptr<FlogLoggerImpl> FlogLoggerImpl::Create(
     InterfaceRequest<FlogLogger> request,
     uint32_t log_id,
     const std::string& label,
     std::shared_ptr<FlogDirectory> directory,
     FlogServiceImpl* owner) {
   return std::shared_ptr<FlogLoggerImpl>(
       new FlogLoggerImpl(request.Pass(), log_id, label, directory, owner));
 }
 
 FlogLoggerImpl::FlogLoggerImpl(InterfaceRequest<FlogLogger> request,
                                uint32_t log_id,
                                const std::string& label,
                                std::shared_ptr<FlogDirectory> directory,
                                FlogServiceImpl* owner)
     : FlogServiceImpl::ProductBase(owner),
       file_(directory->GetFile(log_id, label, true)) {
   mojo::internal::MessageValidatorList validators;
   router_.reset(new mojo::internal::Router(
       request.PassMessagePipe(), std::move(validators),
       Environment::GetDefaultAsyncWaiter()));
   router_->set_incoming_receiver(this);
   router_->set_connection_error_handler([this]() { ReleaseFromOwner(); });
+  stub_.set_sink(this);
 }
 
 FlogLoggerImpl::~FlogLoggerImpl() {}
 
 bool FlogLoggerImpl::Accept(Message* message) {
   DCHECK(message != nullptr);
   DCHECK(message->data_num_bytes() > 0);
   DCHECK(message->data() != nullptr);
 
   uint32_t message_size = message->data_num_bytes();
 
   WriteData(sizeof(message_size), &message_size);
   WriteData(message_size, message->data());
 
+  // Call the stub to output mojo logger messages to stderr. This has to
+  // happen after we write the message to the file, because deserialization
+  // mutates the message.
+  // TODO(dalesat): Provide a switch to turn this off.
+  stub_.Accept(message);
+
   return true;
 }
 
 bool FlogLoggerImpl::AcceptWithResponder(Message* message,
                                          MessageReceiverWithStatus* responder) {
   DCHECK(false) << "FlogLogger has no methods with responses";
   abort();
 }
 
 void FlogLoggerImpl::WriteData(uint32_t data_size, const void* data) {
   DCHECK(data_size > 0);
   DCHECK(data != nullptr);
   DCHECK(file_);
 
   Array<uint8_t> bytes_to_write = Array<uint8_t>::New(data_size);
   memcpy(bytes_to_write.data(), data, data_size);
   file_->Write(bytes_to_write.Pass(), 0, files::Whence::FROM_CURRENT,
                [data_size](files::Error error, uint32 bytes_written) {
                  DCHECK(error == files::Error::OK);
                  DCHECK(bytes_written == data_size);
                  // TODO(dalesat): Handle error.
                });
 }
 
+void FlogLoggerImpl::LogMojoLoggerMessage(int64_t time_us,
+                                          int32_t log_level,
+                                          const String& message,
+                                          const String& source_file,
+                                          uint32_t source_line) {
+  std::cerr << AsMicroseconds(time_us) << " " << AsLogLevel(log_level) << ":"
+            << source_file << "#" << source_line << " " << message << std::endl;
+}
+
+void FlogLoggerImpl::LogChannelCreation(int64_t time_us,
+                                        uint32_t channel_id,
+                                        const String& type_name) {}
+
+void FlogLoggerImpl::LogChannelMessage(int64_t time_us,
+                                       uint32_t channel_id,
+                                       mojo::Array<uint8_t> data) {}
+
+void FlogLoggerImpl::LogChannelDeletion(int64_t time_us, uint32_t channel_id) {}
+
 }  // namespace flog
 }  // namespace mojo