Tracing V2: Proto fields reflection.

components/tracing/tools/proto_zero_plugin/proto_zero_generator.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 "proto_zero_generator.h"
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
@@ skipping 27 matching lines @@
   return StripSuffixString(proto->name(), ".proto") + ".pbzero";
 }
 
 class GeneratorJob {
  public:
   GeneratorJob(const FileDescriptor *file,
                Printer* stub_h_printer,
                Printer* stub_cc_printer)
     : source_(file),
       stub_h_(stub_h_printer),
-      stub_cc_(stub_cc_printer) {}
+      stub_cc_(stub_cc_printer),
+      generate_reflection_(false) {}
 
   bool GenerateStubs() {
     Preprocess();
     GeneratePrologue();
     for (const EnumDescriptor* enumeration: enums_)
       GenerateEnumDescriptor(enumeration);
     for (const Descriptor* message : messages_)
       GenerateMessageDescriptor(message);
     GenerateEpilogue();
     return error_.empty();
   }
 
   void SetOption(const std::string& name, const std::string& value) {
     if (name == "wrapper_namespace") {
       wrapper_namespace_ = value;
+    } else if (name == "reflection") {

[Primiano Tucci (use gerrit), 2016/09/01 16:18:06]

ditto, less code to maintain plz :)

+      if (value == "true" || value == "1") {
+        generate_reflection_ = true;

[picksi1, 2016/09/01 16:38:39]

There is an implication that generate_reflection defaults to false here, which
may change at some future point? Should this if/else (or switch if it changes)
set generate_reflection to false if value == 'false' || value = '1' and move
this Abort into the else branch.

+      } else if (value != "false" && value != "0") {
+        Abort(std::string() + "Invalid 'reflection' value '" + value + "'.");
+      }
     } else {
       Abort(std::string() + "Unknown plugin option '" + name + "'.");
     }
   }
 
   // If generator fails to produce stubs for a particular proto definitions
   // it finishes with undefined output and writes the first error occured.
   const std::string& GetFirstError() const {
     return error_;
   }
@@ skipping 20 matching lines @@
   // prohibited but not recommended in order to avoid name collisions.
   template <class T>
   inline std::string GetCppClassName(const T* descriptor, bool full = false) {
     std::string name = GetDescriptorName(descriptor);
     StripString(&name, ".", '_');
     if (full)
       name = full_namespace_prefix_ + name;
     return name;
   }
 
+  inline std::string Capitalize(const std::string& str) {

[picksi1, 2016/09/01 16:38:39]

Could you use Capitalize() in the SetOption function and compare with TRUE and
FALSE, as currently passing 'True' or 'False' (i.e. capitalized) would fail.

+    std::string copy(str);
+    copy.at(0) = toupper(copy.at(0));
+    return copy;
+  }
+
+  inline std::string GetFieldNumberConstant(const FieldDescriptor* field) {
+    std::string name = field->camelcase_name();
+    if (!name.empty()) {
+      name = std::string("k") + Capitalize(name) + "FieldNumber";
+    } else {
+      // Protoc allows fields like 'bool _ = 1'.
+      Abort("Empty field name in camel case notation.");
+    }
+    return name;
+  }
+
   // Small enums can be written faster without involving VarInt encoder.
   inline bool IsTinyEnumField(const FieldDescriptor* field) {
     if (field->type() != FieldDescriptor::TYPE_ENUM)
       return false;
     const EnumDescriptor* enumeration = field->enum_type();
 
     for (int i = 0; i < enumeration->value_count(); ++i) {
       int32_t value = enumeration->value(i)->number();
       if (value < 0 || value > 0x7F)
         return false;
@@ skipping 142 matching lines @@
     stub_h_->Print("\n");
 
     // Print includes for private imports to .cc file.
     for (const FileDescriptor* dependency : private_imports_) {
       stub_cc_->Print(
          "#include \"$name$.h\"\n",
          "name", ProtoStubName(dependency));
     }
     stub_cc_->Print("\n");
 
+    if (generate_reflection_ && messages_.size() > 0)
+      stub_cc_->Print(
+          "namespace {\n"
+          "  static const ::tracing::v2::proto::ProtoFieldDescriptor "
+          "__invalid_field = {\"\", "

[Primiano Tucci (use gerrit), 2016/09/01 16:18:06]

just calling kInvalidField should be enough and fits our naming conventions.

+          "::tracing::v2::proto::ProtoFieldDescriptor::Type::TYPE_INVALID, "
+          "0, false};\n"
+          "}\n\n");
+
     // Print namespaces.
     for (const std::string& ns : namespaces_) {
       stub_h_->Print("namespace $ns$ {\n", "ns", ns);
       stub_cc_->Print("namespace $ns$ {\n", "ns", ns);
     }
     stub_h_->Print("\n");
     stub_cc_->Print("\n");
 
     // Print forward declarations.
     for (const Descriptor* message : referenced_messages_) {
@@ skipping 152 matching lines @@
         "$inner_class$* $outer_class$::$action$_$name$() {\n"
         "  return BeginNestedMessage<$inner_class$>($id$);\n"
         "}\n\n",
         "id", std::to_string(field->number()),
         "name", field->name(),
         "action", action,
         "inner_class", inner_class,
         "outer_class", outer_class);
   }
 
+  void GenerateReflectionHelpers(const Descriptor* message) {
+    // Field numbers.
+    if (message->field_count() > 0) {

[picksi1, 2016/09/01 16:38:39]

There are a number of places where the code has this if >0 statement. If we own
the Descriptor class (not sure?) should we add a new function called
has_fields() to wrap this repeated functionality?

+      stub_h_->Print("enum : int32_t {\n");
+      stub_h_->Indent();
+
+      for (int i = 0; i < message->field_count(); ++i) {
+        const FieldDescriptor* field = message->field(i);
+        stub_h_->Print(
+            "$name$ = $id$,\n",
+            "name", GetFieldNumberConstant(field),
+            "id", std::to_string(field->number()));
+      }
+      stub_h_->Outdent();
+      stub_h_->Print("};\n");
+    }
+
+    // Fields reflection.
+    stub_h_->Print(
+        "static const ::tracing::v2::proto::ProtoFieldDescriptor* "
+        "GetFieldDescriptor(uint32_t field_id);\n");
+
+    std::string class_name = GetCppClassName(message);
+    if (message->field_count() > 0) {
+      stub_cc_->Print(
+          "static const ::tracing::v2::proto::ProtoFieldDescriptor "
+          "__fields_$class$[] = {\n",

[Primiano Tucci (use gerrit), 2016/09/01 16:18:06]

ditto, just kFields...
as this is a non exported symbol is extremely unlikely to clash, no need to __
magic I think :)

+          "class", class_name);
+      stub_cc_->Indent();
+      for (int i = 0; i < message->field_count(); ++i) {
+        const FieldDescriptor* field = message->field(i);
+        // Caveats:
+        // There is assumption that field type enums (protoc and ProtoZero) have
+        // same numbers for corresponding types. Hence, there is a test.

[Primiano Tucci (use gerrit), 2016/09/01 16:18:06]

s/Hence, there is a test./This is covered by TEST_NAME in 
...blabla_unittest.cc/

+        stub_cc_->Print(
+            "{\"$name$\", static_cast"
+            "<::tracing::v2::proto::ProtoFieldDescriptor::Type>($type$), "
+            "$number$, $is_repeated$},\n",
+            "name", field->name(),
+            "type", std::to_string(static_cast<int>(field->type())),
+            "number", std::to_string(field->number()),
+            "is_repeated", std::to_string(field->is_repeated()));
+      }
+      stub_cc_->Outdent();
+      stub_cc_->Print("};\n\n");
+    }
+
+    stub_cc_->Print(
+        "const ::tracing::v2::proto::ProtoFieldDescriptor* "
+        "$class$::GetFieldDescriptor(uint32_t field_id) {\n",
+        "class", class_name);
+    stub_cc_->Indent();
+    if (message->field_count() > 0) {
+      stub_cc_->Print("switch (field_id) {\n");
+      stub_cc_->Indent();
+      for (int i = 0; i < message->field_count(); ++i) {
+        stub_cc_->Print(
+            "case $field$:\n"
+            "  return &__fields_$class$[$id$];\n",
+            "class", class_name,
+            "field", GetFieldNumberConstant(message->field(i)),
+            "id", std::to_string(i));
+      }
+      stub_cc_->Print(
+          "default:\n"
+          "  return &__invalid_field;\n");
+      stub_cc_->Outdent();
+      stub_cc_->Print("}\n");
+    } else {
+      stub_cc_->Print("return &__invalid_field;\n");
+    }
+    stub_cc_->Outdent();
+    stub_cc_->Print("}\n\n");
+  }
+
   void GenerateMessageDescriptor(const Descriptor* message) {
     stub_h_->Print(
         "class $name$ : public ::tracing::v2::ProtoZeroMessage {\n"
         " public:\n",
         "name", GetCppClassName(message));
     stub_h_->Indent();
 
+    if (generate_reflection_)
+      GenerateReflectionHelpers(message);

[picksi1, 2016/09/01 16:38:39]

Is this function correctly named GenerateReflectionHelpers()? The code reads
slightly oddly as the condition is called generater_reflection, so should this
function just be called GenerateReflection()?

+
     // Using statements for nested messages.
     for (int i = 0; i < message->nested_type_count(); ++i) {
       const Descriptor* nested_message = message->nested_type(i);
       stub_h_->Print(
           "using $local_name$ = $global_name$;\n",
           "local_name", nested_message->name(),
           "global_name", GetCppClassName(nested_message, true));
     }
 
     // Using statements for nested enums.
@@ skipping 13 matching lines @@
       for (int j = 0; j < nested_enum->value_count(); ++j) {
         const EnumValueDescriptor* value = nested_enum->value(j);
         stub_h_->Print(
             "static const $class$ $name$ = $full_name$;\n",
             "class", nested_enum->name(),
             "name", value->name(),
             "full_name", value_name_prefix + value->name());
       }
     }
 
-    // Field numbers.
-    if (message->field_count() > 0) {
-      stub_h_->Print("enum : int32_t {\n");
-      stub_h_->Indent();
-
-      for (int i = 0; i < message->field_count(); ++i) {
-        const FieldDescriptor* field = message->field(i);
-        std::string name = field->camelcase_name();
-        if (!name.empty()) {
-          name.at(0) = toupper(name.at(0));
-        } else {
-          // Protoc allows fields like 'bool _ = 1'.
-          Abort("Empty field name in camel case notation.");
-        }
-
-        stub_h_->Print(
-            "k$name$FieldNumber = $id$,\n",
-            "name", name,
-            "id", std::to_string(field->number()));
-      }
-      stub_h_->Outdent();
-      stub_h_->Print("};\n");
-    }
-
     // Field descriptors.
     for (int i = 0; i < message->field_count(); ++i) {
       const FieldDescriptor* field = message->field(i);
       if (field->is_packed()) {
         Abort("Packed repeated fields are not supported.");
         return;
       }
       if (field->type() != FieldDescriptor::TYPE_MESSAGE) {
         GenerateSimpleFieldDescriptor(field);
       } else {
@@ skipping 11 matching lines @@
       stub_cc_->Print("} // Namespace.\n");
     }
     stub_h_->Print("#endif  // Include guard.\n");
   }
 
   const FileDescriptor* const source_;
   Printer* const stub_h_;
   Printer* const stub_cc_;
   std::string error_;
 
+  bool generate_reflection_;
   std::string package_;
   std::string wrapper_namespace_;
   std::vector<std::string> namespaces_;
   std::string full_namespace_prefix_;
   std::vector<const Descriptor*> messages_;
   std::vector<const EnumDescriptor*> enums_;
 
   std::set<const FileDescriptor*> public_imports_;
   std::set<const FileDescriptor*> private_imports_;
   std::set<const Descriptor*> referenced_messages_;
@@ skipping 31 matching lines @@
 
   if (!job.GenerateStubs()) {
     *error = job.GetFirstError();
     return false;
   }
   return true;
 }
 
 }  // namespace proto
 }  // namespace tracing