Tracing V2: Proto fields reflection.

components/tracing/core/proto_utils.h

 // 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.
 
 #ifndef COMPONENTS_TRACING_CORE_PROTO_UTILS_H_
 #define COMPONENTS_TRACING_CORE_PROTO_UTILS_H_
 
 #include <inttypes.h>
 
 #include <type_traits>
 
 #include "base/logging.h"
 
 namespace tracing {
 namespace v2 {
 namespace proto {
 
 // See https://developers.google.com/protocol-buffers/docs/encoding wire types.
 
 enum : uint32_t {
   kFieldTypeVarInt = 0,
   kFieldTypeFixed64 = 1,
   kFieldTypeLengthDelimited = 2,
   kFieldTypeFixed32 = 5,
 };
 
+class ProtoFieldDescriptor {
+ public:
+  enum Type {
+    TYPE_INVALID = 0,
+    TYPE_DOUBLE = 1,
+    TYPE_FLOAT = 2,
+    TYPE_INT64 = 3,
+    TYPE_UINT64 = 4,
+    TYPE_INT32 = 5,
+    TYPE_FIXED64 = 6,
+    TYPE_FIXED32 = 7,
+    TYPE_BOOL = 8,
+    TYPE_STRING = 9,
+    TYPE_MESSAGE = 11,
+    TYPE_BYTES = 12,
+    TYPE_UINT32 = 13,
+    TYPE_ENUM = 14,
+    TYPE_SFIXED32 = 15,
+    TYPE_SFIXED64 = 16,
+    TYPE_SINT32 = 17,
+    TYPE_SINT64 = 18,
+    // TYPE_GROUP = 10 is not supported.

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

Should this comment be put at the 'correct' place in the enum (i.e. between 9
and 11)? Is there a danger a future developer will see the gap, not read the
comment, and re-use 10 for something else?

+  };
+
+  ProtoFieldDescriptor(const char* name,

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

is this git-cl formatted?

+                       Type type,
+                       uint32_t number,
+                       bool is_repeated) : name_(name),
+                                           type_(type),
+                                           number_(number),
+                                           is_repeated_(is_repeated) {
+  }
+
+  const char* name() const {
+    return name_;
+  }
+
+  Type type() const {
+    return type_;
+  }
+
+  uint32_t number() const {
+    return number_;
+  }
+
+  bool is_repeated() const {
+    return is_repeated_;
+  }
+
+  bool is_valid() const {
+    return type_ != Type::TYPE_INVALID;
+  }
+
+ private:
+  const char* const name_;
+  const Type type_;
+  const uint32_t number_;
+  const bool is_repeated_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProtoFieldDescriptor);
+};
+
 // Maximum message size supported: 256 MiB (4 x 7-bit due to varint encoding).
 constexpr size_t kMessageLengthFieldSize = 4;
 constexpr size_t kMaxMessageLength = (1u << (kMessageLengthFieldSize * 7)) - 1;
 
 // Field tag is encoded as 32-bit varint (5 bytes at most).
 // Largest value of simple (not length-delimited) field is 64-bit varint
 // (10 bytes at most). 15 bytes buffer is enough to store a simple field.
 constexpr size_t kMaxTagEncodedSize = 5;
 constexpr size_t kMaxSimpleFieldEncodedSize = kMaxTagEncodedSize + 10;
 
@@ skipping 55 matching lines @@
 void StaticAssertSingleBytePreamble() {
   static_assert(field_id < 16,
                 "Proto field id too big to fit in a single byte preamble");
 };
 
 }  // namespace proto
 }  // namespace v2
 }  // namespace tracing
 
 #endif  // COMPONENTS_TRACING_CORE_PROTO_UTILS_H_