Used oneof in blimp_message.proto

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>
 
@@ skipping 151 matching lines @@
       default:
         break;
     }
   }
 };
 
 // Logs fields from PROTOCOL_CONTROL messages.
 class ProtocolControlLogExtractor : public LogExtractor {
   void ExtractFields(const BlimpMessage& message,
                      LogFields* output) const override {
-    switch (message.protocol_control().type()) {
-      case ProtocolControlMessage::START_CONNECTION:
+    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::CHECKPOINT_ACK:
+      case ProtocolControlMessage::kCheckpointAck:
         AddField("subtype", "CHECKPOINT_ACK", output);
         AddField("checkpoint_id",
                  message.protocol_control().checkpoint_ack().checkpoint_id(),
                  output);
         break;
       default:
         break;
     }
   }
 };
@@ skipping 30 matching lines @@
                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 {
-    switch (message.tab_control().type()) {
-      case TabControlMessage::CREATE_TAB:
+    switch (message.tab_control().tab_control_case()) {
+      case TabControlMessage::kCreateTab:
         AddField("subtype", "CREATE_TAB", output);
         break;
-      case TabControlMessage::CLOSE_TAB:
+      case TabControlMessage::kCloseTab:
         AddField("subtype", "CLOSE_TAB", output);
         break;
-      case TabControlMessage::SIZE:
+      case TabControlMessage::kSize:
         AddField("subtype", "SIZE", output);
         AddField("size", message.tab_control().size(), output);
         break;
       default:  // 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::COMPOSITOR,
+  AddHandler("COMPOSITOR", BlimpMessage::kCompositor,
              base::WrapUnique(new CompositorLogExtractor));
-  AddHandler("INPUT", BlimpMessage::INPUT,
+  AddHandler("INPUT", BlimpMessage::kInput,
              base::WrapUnique(new InputLogExtractor));
-  AddHandler("NAVIGATION", BlimpMessage::NAVIGATION,
+  AddHandler("NAVIGATION", BlimpMessage::kNavigation,
              base::WrapUnique(new NavigationLogExtractor));
-  AddHandler("PROTOCOL_CONTROL", BlimpMessage::PROTOCOL_CONTROL,
+  AddHandler("PROTOCOL_CONTROL", BlimpMessage::kProtocolControl,
              base::WrapUnique(new ProtocolControlLogExtractor));
-  AddHandler("RENDER_WIDGET", BlimpMessage::RENDER_WIDGET,
+  AddHandler("RENDER_WIDGET", BlimpMessage::kRenderWidget,
              base::WrapUnique(new RenderWidgetLogExtractor));
-  AddHandler("SETTINGS", BlimpMessage::SETTINGS,
+  AddHandler("SETTINGS", BlimpMessage::kSettings,
              base::WrapUnique(new SettingsLogExtractor));
-  AddHandler("TAB_CONTROL", BlimpMessage::TAB_CONTROL,
+  AddHandler("TAB_CONTROL", BlimpMessage::kTabControl,
              base::WrapUnique(new TabControlLogExtractor));
 }
 
 BlimpMessageLogger::~BlimpMessageLogger() {}
 
-void BlimpMessageLogger::AddHandler(const std::string& type_name,
-                                    BlimpMessage::Type type,
+void BlimpMessageLogger::AddHandler(const std::string& feature_name,
+                                    BlimpMessage::FeatureCase feature_case,
                                     std::unique_ptr<LogExtractor> extractor) {
-  DCHECK(extractors_.find(type) == extractors_.end());
-  DCHECK(!type_name.empty());
-  extractors_[type] = make_pair(type_name, std::move(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 {
   LogFields fields;
 
-  auto extractor = extractors_.find(message.type());
+  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.type(), &fields);
+    AddField("type", message.feature_case(), &fields);
   }
 
   // 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 << ">";
 }
 
 std::ostream& operator<<(std::ostream& out, const BlimpMessage& message) {
   g_logger.Get().LogMessageToStream(message, &out);
   return out;
 }
 
 }  // namespace blimp