Tracing V2: Fully-functional plugin.

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 40 matching lines @@
     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 {
+      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_;
   }
 
  private:
   // Only the first error will be recorded.
   void Abort(const std::string& reason) {
     if (error_.empty())
@@ skipping 116 matching lines @@
           }
         }
       }
     }
   }
 
   void Preprocess() {
     // Package name maps to a series of namespaces.
     package_ = source_->package();
     namespaces_ = Split(package_, ".");
+    if (!wrapper_namespace_.empty())
+      namespaces_.insert(namespaces_.begin(), wrapper_namespace_);
+
     full_namespace_prefix_ = "::";
     for (const std::string& ns : namespaces_)
       full_namespace_prefix_ += ns + "::";
+
     CollectDescriptors();
     CollectDependencies();
   }
 
   // Print top header, namespaces and forward declarations.
   void GeneratePrologue() {
     std::string greeting =
         "// Autogenerated. DO NOT EDIT.\n"
         "// Protobuf compiler (protoc) has generated these stubs with\n"
         "// //components/tracing/tools/proto_zero_plugin.\n";
@@ skipping 84 matching lines @@
     stub_h_->Outdent();
     stub_h_->Print("};\n\n");
   }
 
   void GenerateSimpleFieldDescriptor(const FieldDescriptor* field) {
     std::map<std::string, std::string> setter;
     setter["id"] = std::to_string(field->number());
     setter["name"] = field->name();
     setter["action"] = field->is_repeated() ? "add" : "set";
 
+    if (field->is_repeated()) {
+      setter["dcheck"] = "";
+    } else {
+      setter["dcheck"] =
+          std::string("  DCheckSealField(") + setter["id"] + ");\n  " ;
+    }
+
     std::string appender;
     std::string cpp_type;
 
     switch (field->type()) {
       case FieldDescriptor::TYPE_BOOL: {
-        appender = "AppendBool";
+        appender = "AppendTinyVarInt";
         cpp_type = "bool";
         break;
       }
       case FieldDescriptor::TYPE_INT32: {
-        appender = "AppendInt32";
+        appender = "AppendVarInt";
         cpp_type = "int32_t";
         break;
       }
       case FieldDescriptor::TYPE_INT64: {
-        appender = "AppendInt64";
+        appender = "AppendVarInt";
         cpp_type = "int64_t";
         break;
       }
       case FieldDescriptor::TYPE_UINT32: {
-        appender = "AppendUint32";
+        appender = "AppendVarInt";
         cpp_type = "uint32_t";
         break;
       }
       case FieldDescriptor::TYPE_UINT64: {
-        appender = "AppendUint64";
+        appender = "AppendVarInt";
         cpp_type = "uint64_t";
         break;
       }
       case FieldDescriptor::TYPE_SINT32: {
-        appender = "AppendSint32";
+        appender = "AppendSignedVarInt";
         cpp_type = "int32_t";
         break;
       }
       case FieldDescriptor::TYPE_SINT64: {
-        appender = "AppendSint64";
+        appender = "AppendSignedVarInt";
         cpp_type = "int64_t";
         break;
       }
       case FieldDescriptor::TYPE_FIXED32: {
-        appender = "AppendFixed32";
+        appender = "AppendFixed";
         cpp_type = "uint32_t";
         break;
       }
       case FieldDescriptor::TYPE_FIXED64: {
-        appender = "AppendFixed64";
+        appender = "AppendFixed";
         cpp_type = "uint64_t";
         break;
       }
       case FieldDescriptor::TYPE_SFIXED32: {
-        appender = "AppendSfixed32";
+        appender = "AppendFixed";
         cpp_type = "int32_t";
         break;
       }
       case FieldDescriptor::TYPE_SFIXED64: {
-        appender = "AppendSfixed64";
+        appender = "AppendFixed";
         cpp_type = "int64_t";
         break;
       }
       case FieldDescriptor::TYPE_FLOAT: {
-        appender = "AppendFloat";
+        appender = "AppendFixed";
         cpp_type = "float";
         break;
       }
       case FieldDescriptor::TYPE_DOUBLE: {
-        appender = "AppendDouble";
+        appender = "AppendFixed";
         cpp_type = "double";
         break;
       }
       case FieldDescriptor::TYPE_ENUM: {
-        appender = IsTinyEnumField(field) ? "AppendTinyNumber" : "AppendInt32";
+        appender = IsTinyEnumField(field) ? "AppendTinyVarInt" : "AppendVarInt";
         cpp_type = GetCppClassName(field->enum_type(), true);
         break;
       }
       case FieldDescriptor::TYPE_STRING: {
         appender = "AppendString";
         cpp_type = "const char*";
         break;
       }
       case FieldDescriptor::TYPE_BYTES: {
         stub_h_->Print(
             setter,
             "void $action$_$name$(const uint8_t* data, size_t size) {\n"
-            "  // AppendBytes($id$, data, size);\n"
+            "$dcheck$  AppendBytes($id$, data, size);\n"
             "}\n");
         return;
       }
       default: {
         Abort("Unsupported field type.");
         return;
       }
     }
     setter["appender"] = appender;
     setter["cpp_type"] = cpp_type;
     stub_h_->Print(
         setter,
         "void $action$_$name$($cpp_type$ value) {\n"
-        "  // $appender$($id$, value);\n"
+        "$dcheck$  $appender$($id$, value);\n"
         "}\n");
   }
 
   void GenerateNestedMessageFieldDescriptor(const FieldDescriptor* field) {
     std::string action = field->is_repeated() ? "add" : "set";
     std::string inner_class = GetCppClassName(field->message_type());
     std::string outer_class = GetCppClassName(field->containing_type());
 
     stub_h_->Print(
         "$inner_class$* $action$_$name$();\n",
@@ skipping 100 matching lines @@
     }
     stub_h_->Print("#endif  // Include guard.\n");
   }
 
   const FileDescriptor* const source_;
   Printer* const stub_h_;
   Printer* const stub_cc_;
   std::string error_;
 
   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_;
   std::set<const EnumDescriptor*> referenced_enums_;
 };
@@ skipping 12 matching lines @@
                                   std::string* error) const {
 
   const std::unique_ptr<ZeroCopyOutputStream> stub_h_file_stream(
       context->Open(ProtoStubName(file) + ".h"));
   const std::unique_ptr<ZeroCopyOutputStream> stub_cc_file_stream(
       context->Open(ProtoStubName(file) + ".cc"));
 
   // Variables are delimited by $.
   Printer stub_h_printer(stub_h_file_stream.get(), '$');
   Printer stub_cc_printer(stub_cc_file_stream.get(), '$');
+  GeneratorJob job(file, &stub_h_printer, &stub_cc_printer);
 
-  GeneratorJob job(file, &stub_h_printer, &stub_cc_printer);
+  // Parse additional options.
+  for (const std::string& option : Split(options, ",")) {
+    std::vector<std::string> option_pair = Split(option, "=");
+    job.SetOption(option_pair[0], option_pair[1]);
+  }
+
   if (!job.GenerateStubs()) {
     *error = job.GetFirstError();
     return false;
   }
   return true;
 }
 
 }  // namespace proto
 }  // namespace tracing