Tracing V2: Proto message and utils improvements.

components/tracing/core/proto_zero_message_unittest.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 "components/tracing/core/proto_zero_message.h"
 
 #include <limits>
 #include <memory>
 #include <vector>
 
@@ skipping 69 matching lines @@
     for (uint32_t i = 1; i <= 128; ++i)
       msg->AppendBytes(i, kTestBytes, sizeof(kTestBytes));
 
     if (depth < ProtoZeroMessage::kMaxNestingDepth) {
       auto* nested_msg =
           msg->BeginNestedMessage<FakeChildMessage>(1 + depth * 10);
       BuildNestedMessages(depth + 1, nested_msg);
     }
 
     for (uint32_t i = 129; i <= 256; ++i)
-      msg->AppendVarIntU32(i, 42);
+      msg->AppendVarInt(i, 42);
 
     if ((depth & 2) == 0)
       msg->Finalize();
   }
 
  private:
   std::unique_ptr<FakeScatteredBuffer> buffer_;
   std::unique_ptr<ScatteredStreamWriter> stream_writer_;
   std::vector<std::unique_ptr<uint8_t[]>> messages_;
   size_t readback_pos_;
 };
 
 TEST_F(ProtoZeroMessageTest, BasicTypesNoNesting) {
   ProtoZeroMessage* msg = NewMessage();
-  msg->AppendVarIntU32(1 /* field_id */, 0);
-  msg->AppendVarIntU32(2 /* field_id */, std::numeric_limits<uint32_t>::max());
-  msg->AppendVarIntU64(3 /* field_id */, 42);
-  msg->AppendVarIntU64(4 /* field_id */, std::numeric_limits<uint64_t>::max());
-  msg->AppendFloat(5 /* field_id */, 3.1415f);
-  msg->AppendDouble(6 /* field_id */, 3.14159265358979323846);
+  msg->AppendVarInt(1 /* field_id */, 0);
+  msg->AppendVarInt(2 /* field_id */, std::numeric_limits<uint32_t>::max());
+  msg->AppendVarInt(3 /* field_id */, 42);
+  msg->AppendVarInt(4 /* field_id */, std::numeric_limits<uint64_t>::max());
+  msg->AppendFixed(5 /* field_id */, 3.1415f /* float */);
+  msg->AppendFixed(6 /* field_id */, 3.14159265358979323846 /* double */);
   msg->AppendBytes(7 /* field_id */, kTestBytes, sizeof(kTestBytes));
 
   // Field ids > 16 are expected to be varint encoded (preamble > 1 byte)
   msg->AppendString(257 /* field_id */, "0123456789abcdefABCDEF");
+  msg->AppendSignedVarInt(3 /* field_id */, -21);
 
-  EXPECT_EQ(72u, msg->Finalize());
-  EXPECT_EQ(72u, GetNumSerializedBytes());
+  EXPECT_EQ(74u, msg->Finalize());
+  EXPECT_EQ(74u, GetNumSerializedBytes());
 
   // These lines match the serialization of the Append* calls above.
   ASSERT_EQ("0800", GetNextSerializedBytes(2));
   ASSERT_EQ("10FFFFFFFF0F", GetNextSerializedBytes(6));
   ASSERT_EQ("182A", GetNextSerializedBytes(2));
   ASSERT_EQ("20FFFFFFFFFFFFFFFFFF01", GetNextSerializedBytes(11));
   ASSERT_EQ("2D560E4940", GetNextSerializedBytes(5));
   ASSERT_EQ("31182D4454FB210940", GetNextSerializedBytes(9));
   ASSERT_EQ("3A0A00000000420142FF4200", GetNextSerializedBytes(12));
   ASSERT_EQ("8A101630313233343536373839616263646566414243444546",
             GetNextSerializedBytes(25));
+  ASSERT_EQ("1829", GetNextSerializedBytes(2));
 }
 
 TEST_F(ProtoZeroMessageTest, NestedMessagesSimple) {
   ProtoZeroMessage* root_msg = NewMessage();
-  root_msg->AppendVarIntU32(1 /* field_id */, 1);
+  root_msg->AppendVarInt(1 /* field_id */, 1);
 
   FakeChildMessage* nested_msg =
       root_msg->BeginNestedMessage<FakeChildMessage>(128 /* field_id */);
   ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(nested_msg) % sizeof(void*));
-  nested_msg->AppendVarIntU32(2 /* field_id */, 2);
+  nested_msg->AppendVarInt(2 /* field_id */, 2);
 
   nested_msg =
       root_msg->BeginNestedMessage<FakeChildMessage>(129 /* field_id */);
-  nested_msg->AppendVarIntU32(4 /* field_id */, 2);
+  nested_msg->AppendVarInt(4 /* field_id */, 2);
 
-  root_msg->AppendVarIntU32(5 /* field_id */, 3);
+  root_msg->AppendVarInt(5 /* field_id */, 3);
 
   // The expected size of the root message is supposed to be 20 bytes:
   //   2 bytes for the varint field (id: 1) (1 for preamble and one for payload)
   //   6 bytes for the preamble of the 1st nested message (2 for id, 4 for size)
   //   2 bytes for the varint field (id: 2) of the 1st nested message
   //   6 bytes for the premable of the 2nd nested message
   //   2 bytes for the varint field (id: 4) of the 2nd nested message.
   //   2 bytes for the last varint (id : 5) field of the root message.
   // Test also that finalization is idempontent and Finalize() can be safely
   // called more than once without side effects.
@@ skipping 13 matching lines @@
   ASSERT_EQ("2803", GetNextSerializedBytes(2));
 }
 
 // Checks that the size field of root and nested messages is properly written
 // on finalization.
 TEST_F(ProtoZeroMessageTest, BackfillSizeOnFinalization) {
   ProtoZeroMessage* root_msg = NewMessage();
   uint8_t root_msg_size[proto::kMessageLengthFieldSize] = {};
   root_msg->set_size_field(
       {&root_msg_size[0], &root_msg_size[proto::kMessageLengthFieldSize]});
-  root_msg->AppendVarIntU32(1, 0x42);
+  root_msg->AppendVarInt(1, 0x42);
 
   FakeChildMessage* nested_msg_1 =
       root_msg->BeginNestedMessage<FakeChildMessage>(2);
-  nested_msg_1->AppendVarIntU32(3, 0x43);
+  nested_msg_1->AppendVarInt(3, 0x43);
 
   FakeChildMessage* nested_msg_2 =
       nested_msg_1->BeginNestedMessage<FakeChildMessage>(4);
   uint8_t buf200[200];
   memset(buf200, 0x42, sizeof(buf200));
   nested_msg_2->AppendBytes(5, buf200, sizeof(buf200));
 
   root_msg->inc_size_already_written(6);
 
   // The value returned by Finalize() should be == the full size of |root_msg|.
@@ skipping 101 matching lines @@
 #endif
 
   // Test also the behavior of handle with non-root (nested) messages.
 
   ContiguousMemoryRange size_msg_2;
   {
     auto* nested_msg_1 = NewMessage()->BeginNestedMessage<FakeChildMessage>(3);
     ProtoZeroMessageHandle<FakeChildMessage> child_handle_1(nested_msg_1);
     ContiguousMemoryRange size_msg_1 = nested_msg_1->size_field();
     memset(size_msg_1.begin, 0, size_msg_1.size());
-    child_handle_1->AppendVarIntU32(1, 0x11);
+    child_handle_1->AppendVarInt(1, 0x11);
 
     auto* nested_msg_2 = NewMessage()->BeginNestedMessage<FakeChildMessage>(2);
     size_msg_2 = nested_msg_2->size_field();
     memset(size_msg_2.begin, 0, size_msg_2.size());
     ProtoZeroMessageHandle<FakeChildMessage> child_handle_2(nested_msg_2);
-    child_handle_2->AppendVarIntU32(2, 0xFF);
+    child_handle_2->AppendVarInt(2, 0xFF);
 
     // |nested_msg_1| should not be finalized yet.
     ASSERT_EQ(0u, size_msg_1.begin[0]);
 
     // This move should cause |nested_msg_1| to be finalized, but not
     // |nested_msg_2|, which will be finalized only after the current scope.
     child_handle_1 = std::move(child_handle_2);
     ASSERT_EQ(0x82u, size_msg_1.begin[0]);
     ASSERT_EQ(0u, size_msg_2.begin[0]);
   }
   ASSERT_EQ(0x83u, size_msg_2.begin[0]);
 }
 
 }  // namespace v2
 }  // namespace tracing