Blimp: change logger to use switch/case for types.

blimp/common/logging.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 "blimp/common/logging.h"
 
 #include <iostream>
 #include <string>
 #include <vector>
 
 #include "base/format_macros.h"
 #include "base/json/string_escape.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "blimp/common/create_blimp_message.h"
 #include "blimp/common/proto/blimp_message.pb.h"
 
 namespace blimp {
 namespace {
 
-static base::LazyInstance<BlimpMessageLogger> g_logger =
-    LAZY_INSTANCE_INITIALIZER;
+typedef std::vector<std::pair<std::string, std::string>> LogFields;
 
 // The AddField() suite of functions are used to convert KV pairs with
 // arbitrarily typed values into string/string KV pairs for logging.
 
 // Specialization for string values, surrounding them with quotes and escaping
 // characters as necessary.
 void AddField(const std::string& key,
               const std::string& value,
               LogFields* output) {
   std::string escaped_value;
@@ skipping 26 matching lines @@
 // Uses std::to_string() to serialize |value|.
 template <typename T>
 void AddField(const std::string& key, const T& value, LogFields* output) {
   output->push_back(std::make_pair(key, std::to_string(value)));
 }
 
 // The following LogExtractor subclasses contain logic for extracting loggable
 // fields from BlimpMessages.
 
 // Logs fields from COMPOSITOR messages.
-class CompositorLogExtractor : public LogExtractor {
-  void ExtractFields(const BlimpMessage& message,
-                     LogFields* output) const override {
+class CompositorLogExtractor {
+ public:
+  static void ExtractFields(const BlimpMessage& message, LogFields* output) {

[Wez, 2016/06/01 21:35:15]

Looks like this, and the other static member methods below, can just become
static LogFooFields functions in this .cc?

[Kevin M, 2016/06/02 18:05:00]

Done.

     AddField("render_widget_id", message.compositor().render_widget_id(),
              output);
   }
 };
 
 // Logs fields from INPUT messages.
-class InputLogExtractor : public LogExtractor {
-  void ExtractFields(const BlimpMessage& message,
-                     LogFields* output) const override {
+class InputLogExtractor {
+ public:
+  static void ExtractFields(const BlimpMessage& message, LogFields* output) {
     AddField("render_widget_id", message.input().render_widget_id(), output);
     AddField("timestamp_seconds", message.input().timestamp_seconds(), output);
     switch (message.input().type()) {
       case InputMessage::Type_GestureScrollBegin:
         AddField("subtype", "GestureScrollBegin", output);
         break;
       case InputMessage::Type_GestureScrollEnd:
         AddField("subtype", "GestureScrollEnd", output);
         break;
       case InputMessage::Type_GestureScrollUpdate:
@@ skipping 20 matching lines @@
       case InputMessage::Type_GesturePinchUpdate:
         AddField("subtype", "GesturePinchUpdate", output);
         break;
       default:  // unknown
         break;
     }
   }
 };
 
 // Logs fields from NAVIGATION messages.
-class NavigationLogExtractor : public LogExtractor {
-  void ExtractFields(const BlimpMessage& message,
-                     LogFields* output) const override {
+class NavigationLogExtractor {
+ public:
+  static void ExtractFields(const BlimpMessage& message, LogFields* output) {
     switch (message.navigation().type()) {
       case NavigationMessage::NAVIGATION_STATE_CHANGED:
         AddField("subtype", "NAVIGATION_STATE_CHANGED", output);
         if (message.navigation().navigation_state_changed().has_url()) {
           AddField("url", message.navigation().navigation_state_changed().url(),
                    output);
         }
         if (message.navigation().navigation_state_changed().has_favicon()) {
           AddField(
               "favicon_size",
@@ skipping 24 matching lines @@
       case NavigationMessage::RELOAD:
         AddField("subtype", "RELOAD", output);
         break;
       default:
         break;
     }
   }
 };
 
 // Logs fields from PROTOCOL_CONTROL messages.
-class ProtocolControlLogExtractor : public LogExtractor {
-  void ExtractFields(const BlimpMessage& message,
-                     LogFields* output) const override {
+class ProtocolControlLogExtractor {
+ public:
+  static void ExtractFields(const BlimpMessage& message, LogFields* output) {
     switch (message.protocol_control().connection_message_case()) {
       case ProtocolControlMessage::kStartConnection:
         AddField("subtype", "START_CONNECTION", output);
         AddField("client_token",
                  message.protocol_control().start_connection().client_token(),
                  output);
         AddField(
             "protocol_version",
             message.protocol_control().start_connection().protocol_version(),
             output);
         break;
       case ProtocolControlMessage::kCheckpointAck:
         AddField("subtype", "CHECKPOINT_ACK", output);
         AddField("checkpoint_id",
                  message.protocol_control().checkpoint_ack().checkpoint_id(),
                  output);
         break;
       default:
         break;
     }
   }
 };
 
 // Logs fields from RENDER_WIDGET messages.
-class RenderWidgetLogExtractor : public LogExtractor {
-  void ExtractFields(const BlimpMessage& message,
-                     LogFields* output) const override {
+class RenderWidgetLogExtractor {
+ public:
+  static void ExtractFields(const BlimpMessage& message, LogFields* output) {
     switch (message.render_widget().type()) {
       case RenderWidgetMessage::INITIALIZE:
         AddField("subtype", "INITIALIZE", output);
         break;
       case RenderWidgetMessage::CREATED:
         AddField("subtype", "CREATED", output);
         break;
       case RenderWidgetMessage::DELETED:
         AddField("subtype", "DELETED", output);
         break;
     }
     AddField("render_widget_id", message.render_widget().render_widget_id(),
              output);
   }
 };
 
 // Logs fields from SETTINGS messages.
-class SettingsLogExtractor : public LogExtractor {
-  void ExtractFields(const BlimpMessage& message,
-                     LogFields* output) const override {
+class SettingsLogExtractor {
+ public:
+  static void ExtractFields(const BlimpMessage& message, LogFields* output) {
     if (message.settings().has_engine_settings()) {
       const EngineSettingsMessage& engine_settings =
           message.settings().engine_settings();
       AddField("subtype", "ENGINE_SETTINGS", output);
       AddField("record_whole_document", engine_settings.record_whole_document(),
                output);
       AddField("client_os_info", engine_settings.client_os_info(), output);
     }
   }
 };
 
 // Logs fields from TAB_CONTROL messages.
-class TabControlLogExtractor : public LogExtractor {
-  void ExtractFields(const BlimpMessage& message,
-                     LogFields* output) const override {
+class TabControlLogExtractor {
+ public:
+  static void ExtractFields(const BlimpMessage& message, LogFields* output) {
     switch (message.tab_control().tab_control_case()) {
       case TabControlMessage::kCreateTab:
         AddField("subtype", "CREATE_TAB", output);
         break;
       case TabControlMessage::kCloseTab:
         AddField("subtype", "CLOSE_TAB", output);
         break;
       case TabControlMessage::kSize:
         AddField("subtype", "SIZE", output);
         AddField("size", message.tab_control().size(), output);
         break;
       default:  // unknown
         break;
     }
   }
 };
 
 // Logs fields from BLOB_CHANNEL messages.
-class BlobChannelLogExtractor : public LogExtractor {
-  void ExtractFields(const BlimpMessage& message,
-                     LogFields* output) const override {
+class BlobChannelLogExtractor {
+ public:
+  static void ExtractFields(const BlimpMessage& message, LogFields* output) {
     switch (message.blob_channel().type_case()) {
       case BlobChannelMessage::TypeCase::kTransferBlob:
         AddField("subtype", "TRANSFER_BLOB", output);
         AddField("id",
                  base::HexEncode(
                      message.blob_channel().transfer_blob().blob_id().data(),
                      message.blob_channel().transfer_blob().blob_id().size()),
                  output);
         AddField("payload_size",
                  message.blob_channel().transfer_blob().payload().size(),
                  output);
         break;
       case BlobChannelMessage::TypeCase::TYPE_NOT_SET:  // unknown
         break;
     }
   }
 };
 
-// No fields are extracted from |message|.
-class NullLogExtractor : public LogExtractor {
-  void ExtractFields(const BlimpMessage& message,
-                     LogFields* output) const override {}
-};
-
-}  // namespace
-
-BlimpMessageLogger::BlimpMessageLogger() {
-  AddHandler("COMPOSITOR", BlimpMessage::kCompositor,
-             base::WrapUnique(new CompositorLogExtractor));
-  AddHandler("INPUT", BlimpMessage::kInput,
-             base::WrapUnique(new InputLogExtractor));
-  AddHandler("NAVIGATION", BlimpMessage::kNavigation,
-             base::WrapUnique(new NavigationLogExtractor));
-  AddHandler("PROTOCOL_CONTROL", BlimpMessage::kProtocolControl,
-             base::WrapUnique(new ProtocolControlLogExtractor));
-  AddHandler("RENDER_WIDGET", BlimpMessage::kRenderWidget,
-             base::WrapUnique(new RenderWidgetLogExtractor));
-  AddHandler("SETTINGS", BlimpMessage::kSettings,
-             base::WrapUnique(new SettingsLogExtractor));
-  AddHandler("TAB_CONTROL", BlimpMessage::kTabControl,
-             base::WrapUnique(new TabControlLogExtractor));
-  AddHandler("BLOB_CHANNEL", BlimpMessage::kBlobChannel,
-             base::WrapUnique(new BlobChannelLogExtractor));
-}
-
-BlimpMessageLogger::~BlimpMessageLogger() {}
-
-void BlimpMessageLogger::AddHandler(const std::string& feature_name,
-                                    BlimpMessage::FeatureCase feature_case,
-                                    std::unique_ptr<LogExtractor> extractor) {
-  DCHECK(extractors_.find(feature_case) == extractors_.end());
-  DCHECK(!feature_name.empty());
-  extractors_[feature_case] = make_pair(feature_name, std::move(extractor));
-}
-
-void BlimpMessageLogger::LogMessageToStream(const BlimpMessage& message,
-                                            std::ostream* out) const {
+void LogMessageToStream(const BlimpMessage& message, std::ostream* out) {
   LogFields fields;
 
-  auto extractor = extractors_.find(message.feature_case());
-  if (extractor != extractors_.end()) {
-    // An extractor is registered for |message|.
-    // Add the human-readable name of |message.type|.
-    fields.push_back(make_pair("type", extractor->second.first));
-    extractor->second.second->ExtractFields(message, &fields);
-  } else {
-    // Don't know the human-readable name of |message.type|.
-    // Just represent it using its numeric form instead.
-    AddField("type", message.feature_case(), &fields);
+  switch (message.feature_case()) {
+    case BlimpMessage::kCompositor:
+      fields.push_back(std::make_pair("type", "COMPOSITOR"));
+      CompositorLogExtractor::ExtractFields(message, &fields);
+      break;
+    case BlimpMessage::kInput:
+      fields.push_back(std::make_pair("type", "INPUT"));
+      InputLogExtractor::ExtractFields(message, &fields);
+      break;
+    case BlimpMessage::kNavigation:
+      fields.push_back(std::make_pair("type", "NAVIGATION"));
+      NavigationLogExtractor::ExtractFields(message, &fields);
+      break;
+    case BlimpMessage::kProtocolControl:
+      fields.push_back(std::make_pair("type", "PROTOCOL_CONTROL"));
+      ProtocolControlLogExtractor::ExtractFields(message, &fields);
+      break;
+    case BlimpMessage::kRenderWidget:
+      fields.push_back(std::make_pair("type", "RENDER_WIDGET"));
+      RenderWidgetLogExtractor::ExtractFields(message, &fields);
+      break;
+    case BlimpMessage::kSettings:
+      fields.push_back(std::make_pair("type", "SETTINGS"));
+      SettingsLogExtractor::ExtractFields(message, &fields);
+      break;
+    case BlimpMessage::kTabControl:
+      fields.push_back(std::make_pair("type", "TAB_CONTROL"));
+      TabControlLogExtractor::ExtractFields(message, &fields);
+      break;
+    case BlimpMessage::kBlobChannel:
+      fields.push_back(std::make_pair("type", "BLOB_CHANNEL"));
+      BlobChannelLogExtractor::ExtractFields(message, &fields);
+      break;
+    case BlimpMessage::kIme:
+      fields.push_back(std::make_pair("type", "IME"));
+      break;
+    case BlimpMessage::FEATURE_NOT_SET:
+      fields.push_back(std::make_pair("type", "<UNKNOWN>"));
+      break;
   }
 
   // Append "target_tab_id" (if present) and "byte_size" to the field set.
   if (message.has_target_tab_id()) {
     AddField("target_tab_id", message.target_tab_id(), &fields);
   }
   AddField("byte_size", message.ByteSize(), &fields);
 
   // Format message using the syntax:
   // <BlimpMessage field1=value1 field2="value 2">
   *out << "<BlimpMessage ";
   for (size_t i = 0; i < fields.size(); ++i) {
     *out << fields[i].first << "=" << fields[i].second
          << (i != fields.size() - 1 ? " " : "");
   }
   *out << ">";
 }
 
+}  // namespace
+
 std::ostream& operator<<(std::ostream& out, const BlimpMessage& message) {
-  g_logger.Get().LogMessageToStream(message, &out);
+  LogMessageToStream(message, &out);
   return out;
 }
 
 }  // namespace blimp