Chiebot-Mirror
/
protobuf
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Replace call to proto2::Arena::CreateMessage with Create.

Browse Source 
PiperOrigin-RevId: 610960035
pull/15974/head
Chris Kennelly 1 year ago committed by Copybara-Service
parent 6713c2f646
commit 08523897a5
22 changed files with 145 additions and 165 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 5
      src/google/protobuf/arena_test_util.h
  2. 4
      src/google/protobuf/edition_message_unittest.cc
  3. 31
      src/google/protobuf/extension_set.cc
  4. 2
      src/google/protobuf/extension_set_heavy.cc
  5. 38
      src/google/protobuf/extension_set_unittest.cc
  6. 7
      src/google/protobuf/generated_message_reflection.cc
  7. 53
      src/google/protobuf/generated_message_reflection_unittest.cc
  8. 2
      src/google/protobuf/generated_message_tctable_impl.h
  9. 2
      src/google/protobuf/implicit_weak_message.h
  10. 7
      src/google/protobuf/lite_arena_unittest.cc
  11. 2
      src/google/protobuf/lite_unittest.cc
  12. 2
      src/google/protobuf/map_entry.h
  13. 2
      src/google/protobuf/map_field.h
  14. 7
      src/google/protobuf/map_field_test.cc
  15. 2
      src/google/protobuf/map_test.cc
  16. 17
      src/google/protobuf/map_test.inc
  17. 9
      src/google/protobuf/message_unittest.inc
  18. 4
      src/google/protobuf/message_unittest_legacy_apis.inc
  19. 10
      src/google/protobuf/proto3_arena_lite_unittest.cc
  20. 24
      src/google/protobuf/proto3_arena_unittest.cc
  21. 4
      src/google/protobuf/reflection_ops_unittest.cc
  22. 76
      src/google/protobuf/repeated_field_unittest.cc

5
src/google/protobuf/arena_test_util.h
Unescape View File

@ -46,7 +46,7 @@ void TestParseCorruptedString(const T& message) {
for (int c = 1 + (i % 17); c < 256; c += 2 * c + (i & 3)) {
s[i] ^= c;
Arena arena;
T* message = Arena::CreateMessage<T>(use_arena ? &arena : nullptr);
T* message = Arena::Create<T>(use_arena ? &arena : nullptr);
if (message->ParseFromString(s)) {
++success_count;
}
@ -118,8 +118,7 @@ template <typename T>
class ArenaHolder {
public:
explicit ArenaHolder(Arena* arena)
: field_(Arena::CreateMessage<T>(arena)),
owned_by_arena_(arena != nullptr) {
: field_(Arena::Create<T>(arena)), owned_by_arena_(arena != nullptr) {
ABSL_DCHECK(google::protobuf::Arena::is_arena_constructable<T>::value);
ABSL_DCHECK(google::protobuf::Arena::is_destructor_skippable<T>::value);
}

4
src/google/protobuf/edition_message_unittest.cc
Unescape View File

@ -142,12 +142,12 @@ TEST(EditionMessageTest,
encoded = proto.SerializeAsString();
}
Arena arena;
auto* proto = Arena::CreateMessage<Proto>(&arena);
auto* proto = Arena::Create<Proto>(&arena);
// We don't alter donation here, so it works even if the idx are bad.
ASSERT_TRUE(proto->ParseFromString(encoded));
// Now we alter donation bits. str2's bit (#2) will be off, but its aux_idx
// (#3) will point to a donated string.
proto = Arena::CreateMessage<Proto>(&arena);
proto = Arena::Create<Proto>(&arena);
// String view fields don't allow mutable accessors which obviate the needs
// for donation tracker. We will clean up the internal logic after migration
// to string view fields matures.

31
src/google/protobuf/extension_set.cc
Unescape View File

@ -331,7 +331,7 @@ enum { REPEATED_FIELD, OPTIONAL_FIELD };
extension->is_repeated = true; \
extension->is_packed = packed; \
extension->repeated_##LOWERCASE##_value = \
Arena::CreateMessage<RepeatedField<LOWERCASE>>(arena_); \
Arena::Create<RepeatedField<LOWERCASE>>(arena_); \
} else { \
ABSL_DCHECK_TYPE(*extension, REPEATED_FIELD, UPPERCASE); \
ABSL_DCHECK_EQ(extension->is_packed, packed); \
@ -376,43 +376,43 @@ void* ExtensionSet::MutableRawRepeatedField(int number, FieldType field_type,
static_cast<WireFormatLite::FieldType>(field_type))) {
case WireFormatLite::CPPTYPE_INT32:
extension->repeated_int32_t_value =
Arena::CreateMessage<RepeatedField<int32_t>>(arena_);
Arena::Create<RepeatedField<int32_t>>(arena_);
break;
case WireFormatLite::CPPTYPE_INT64:
extension->repeated_int64_t_value =
Arena::CreateMessage<RepeatedField<int64_t>>(arena_);
Arena::Create<RepeatedField<int64_t>>(arena_);
break;
case WireFormatLite::CPPTYPE_UINT32:
extension->repeated_uint32_t_value =
Arena::CreateMessage<RepeatedField<uint32_t>>(arena_);
Arena::Create<RepeatedField<uint32_t>>(arena_);
break;
case WireFormatLite::CPPTYPE_UINT64:
extension->repeated_uint64_t_value =
Arena::CreateMessage<RepeatedField<uint64_t>>(arena_);
Arena::Create<RepeatedField<uint64_t>>(arena_);
break;
case WireFormatLite::CPPTYPE_DOUBLE:
extension->repeated_double_value =
Arena::CreateMessage<RepeatedField<double>>(arena_);
Arena::Create<RepeatedField<double>>(arena_);
break;
case WireFormatLite::CPPTYPE_FLOAT:
extension->repeated_float_value =
Arena::CreateMessage<RepeatedField<float>>(arena_);
Arena::Create<RepeatedField<float>>(arena_);
break;
case WireFormatLite::CPPTYPE_BOOL:
extension->repeated_bool_value =
Arena::CreateMessage<RepeatedField<bool>>(arena_);
Arena::Create<RepeatedField<bool>>(arena_);
break;
case WireFormatLite::CPPTYPE_ENUM:
extension->repeated_enum_value =
Arena::CreateMessage<RepeatedField<int>>(arena_);
Arena::Create<RepeatedField<int>>(arena_);
break;
case WireFormatLite::CPPTYPE_STRING:
extension->repeated_string_value =
Arena::CreateMessage<RepeatedPtrField<std::string>>(arena_);
Arena::Create<RepeatedPtrField<std::string>>(arena_);
break;
case WireFormatLite::CPPTYPE_MESSAGE:
extension->repeated_message_value =
Arena::CreateMessage<RepeatedPtrField<MessageLite>>(arena_);
Arena::Create<RepeatedPtrField<MessageLite>>(arena_);
break;
}
}
@ -501,8 +501,7 @@ void ExtensionSet::AddEnum(int number, FieldType type, bool packed, int value,
ABSL_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_ENUM);
extension->is_repeated = true;
extension->is_packed = packed;
extension->repeated_enum_value =
Arena::CreateMessage<RepeatedField<int>>(arena_);
extension->repeated_enum_value = Arena::Create<RepeatedField<int>>(arena_);
} else {
ABSL_DCHECK_TYPE(*extension, REPEATED_FIELD, ENUM);
ABSL_DCHECK_EQ(extension->is_packed, packed);
@ -564,7 +563,7 @@ std::string* ExtensionSet::AddString(int number, FieldType type,
extension->is_repeated = true;
extension->is_packed = false;
extension->repeated_string_value =
Arena::CreateMessage<RepeatedPtrField<std::string>>(arena_);
Arena::Create<RepeatedPtrField<std::string>>(arena_);
} else {
ABSL_DCHECK_TYPE(*extension, REPEATED_FIELD, STRING);
}
@ -782,7 +781,7 @@ MessageLite* ExtensionSet::AddMessage(int number, FieldType type,
ABSL_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_MESSAGE);
extension->is_repeated = true;
extension->repeated_message_value =
Arena::CreateMessage<RepeatedPtrField<MessageLite>>(arena_);
Arena::Create<RepeatedPtrField<MessageLite>>(arena_);
} else {
ABSL_DCHECK_TYPE(*extension, REPEATED_FIELD, MESSAGE);
}
@ -974,7 +973,7 @@ void ExtensionSet::InternalExtensionMergeFrom(const MessageLite* extendee,
case WireFormatLite::CPPTYPE_##UPPERCASE: \
if (is_new) { \
extension->repeated_##LOWERCASE##_value = \
Arena::CreateMessage<REPEATED_TYPE>(arena_); \
Arena::Create<REPEATED_TYPE>(arena_); \
} \
extension->repeated_##LOWERCASE##_value->MergeFrom( \
*other_extension.repeated_##LOWERCASE##_value); \

2
src/google/protobuf/extension_set_heavy.cc
Unescape View File

@ -208,7 +208,7 @@ ExtensionSet::Extension* ExtensionSet::MaybeNewRepeatedExtension(
ABSL_DCHECK_EQ(cpp_type(extension->type), FieldDescriptor::CPPTYPE_MESSAGE);
extension->is_repeated = true;
extension->repeated_message_value =
Arena::CreateMessage<RepeatedPtrField<MessageLite> >(arena_);
Arena::Create<RepeatedPtrField<MessageLite> >(arena_);
} else {
ABSL_DCHECK_TYPE(*extension, REPEATED, MESSAGE);
}

38
src/google/protobuf/extension_set_unittest.cc
Unescape View File

@ -186,7 +186,7 @@ TEST(ExtensionSetTest, ReleaseExtension) {
TEST(ExtensionSetTest, ArenaUnsafeArenaSetAllocatedAndRelease) {
Arena arena;
unittest::TestAllExtensions* message =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
Arena::Create<unittest::TestAllExtensions>(&arena);
unittest::ForeignMessage extension;
message->UnsafeArenaSetAllocatedExtension(
unittest::optional_foreign_message_extension, &extension);
@ -232,7 +232,7 @@ TEST(ExtensionSetTest, UnsafeArenaSetAllocatedAndRelease) {
TEST(ExtensionSetTest, ArenaUnsafeArenaReleaseOfHeapAlloc) {
Arena arena;
unittest::TestAllExtensions* message =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
Arena::Create<unittest::TestAllExtensions>(&arena);
unittest::ForeignMessage* extension = new unittest::ForeignMessage;
message->SetAllocatedExtension(unittest::optional_foreign_message_extension,
extension);
@ -363,7 +363,7 @@ TEST(ExtensionSetTest, SwapExtensionBothFull) {
TEST(ExtensionSetTest, ArenaSetAllExtension) {
Arena arena1;
unittest::TestAllExtensions* message1 =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena1);
Arena::Create<unittest::TestAllExtensions>(&arena1);
TestUtil::SetAllExtensions(message1);
TestUtil::ExpectAllExtensionsSet(*message1);
}
@ -371,7 +371,7 @@ TEST(ExtensionSetTest, ArenaSetAllExtension) {
TEST(ExtensionSetTest, ArenaCopyConstructor) {
Arena arena1;
unittest::TestAllExtensions* message1 =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena1);
Arena::Create<unittest::TestAllExtensions>(&arena1);
TestUtil::SetAllExtensions(message1);
unittest::TestAllExtensions message2(*message1);
arena1.Reset();
@ -381,7 +381,7 @@ TEST(ExtensionSetTest, ArenaCopyConstructor) {
TEST(ExtensionSetTest, ArenaMergeFrom) {
Arena arena1;
unittest::TestAllExtensions* message1 =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena1);
Arena::Create<unittest::TestAllExtensions>(&arena1);
TestUtil::SetAllExtensions(message1);
unittest::TestAllExtensions message2;
message2.MergeFrom(*message1);
@ -392,8 +392,8 @@ TEST(ExtensionSetTest, ArenaMergeFrom) {
TEST(ExtensionSetTest, ArenaMergeFromWithClearedExtensions) {
Arena arena;
{
auto* message1 = Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
auto* message2 = Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
auto* message1 = Arena::Create<unittest::TestAllExtensions>(&arena);
auto* message2 = Arena::Create<unittest::TestAllExtensions>(&arena);
// Set an extension and then clear it
message1->SetExtension(unittest::optional_int32_extension, 1);
@ -408,8 +408,8 @@ TEST(ExtensionSetTest, ArenaMergeFromWithClearedExtensions) {
{
// As more complicated case, let's have message1 and message2 share some
// uncleared extensions in common.
auto* message1 = Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
auto* message2 = Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
auto* message1 = Arena::Create<unittest::TestAllExtensions>(&arena);
auto* message2 = Arena::Create<unittest::TestAllExtensions>(&arena);
// Set int32 and uint32 on both messages.
message1->SetExtension(unittest::optional_int32_extension, 1);
@ -432,7 +432,7 @@ TEST(ExtensionSetTest, ArenaMergeFromWithClearedExtensions) {
TEST(ExtensionSetTest, ArenaSetAllocatedMessageAndRelease) {
Arena arena;
unittest::TestAllExtensions* message =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
Arena::Create<unittest::TestAllExtensions>(&arena);
EXPECT_FALSE(
message->HasExtension(unittest::optional_foreign_message_extension));
// Add a extension using SetAllocatedExtension
@ -456,9 +456,9 @@ TEST(ExtensionSetTest, SwapExtensionBothFullWithArena) {
std::unique_ptr<Arena> arena2(new Arena());
unittest::TestAllExtensions* message1 =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena1);
Arena::Create<unittest::TestAllExtensions>(&arena1);
unittest::TestAllExtensions* message2 =
Arena::CreateMessage<unittest::TestAllExtensions>(arena2.get());
Arena::Create<unittest::TestAllExtensions>(arena2.get());
TestUtil::SetAllExtensions(message1);
TestUtil::SetAllExtensions(message2);
@ -478,9 +478,9 @@ TEST(ExtensionSetTest, SwapExtensionBothFullWithArena) {
Arena arena3, arena4;
unittest::TestAllExtensions* message3 =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena3);
Arena::Create<unittest::TestAllExtensions>(&arena3);
unittest::TestAllExtensions* message4 =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena4);
Arena::Create<unittest::TestAllExtensions>(&arena4);
TestUtil::SetAllExtensions(message3);
message3->Swap(message4);
arena3.Reset();
@ -492,9 +492,9 @@ TEST(ExtensionSetTest, SwapFieldsOfExtensionBothFullWithArena) {
Arena* arena2 = new Arena();
unittest::TestAllExtensions* message1 =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena1);
Arena::Create<unittest::TestAllExtensions>(&arena1);
unittest::TestAllExtensions* message2 =
Arena::CreateMessage<unittest::TestAllExtensions>(arena2);
Arena::Create<unittest::TestAllExtensions>(arena2);
TestUtil::SetAllExtensions(message1);
TestUtil::SetAllExtensions(message2);
@ -826,7 +826,7 @@ TEST(ExtensionSetTest, SpaceUsedExcludingSelf) {
#define TEST_REPEATED_EXTENSIONS_SPACE_USED(type, cpptype, value) \
do { \
std::unique_ptr<unittest::TestAllExtensions> message( \
Arena::CreateMessage<unittest::TestAllExtensions>(nullptr)); \
Arena::Create<unittest::TestAllExtensions>(nullptr)); \
const size_t base_size = message->SpaceUsedLong(); \
size_t min_expected_size = sizeof(RepeatedField<cpptype>) + base_size; \
message->AddExtension(unittest::repeated_##type##_extension, value); \
@ -875,7 +875,7 @@ TEST(ExtensionSetTest, SpaceUsedExcludingSelf) {
// Repeated strings
{
std::unique_ptr<unittest::TestAllExtensions> message(
Arena::CreateMessage<unittest::TestAllExtensions>(nullptr));
Arena::Create<unittest::TestAllExtensions>(nullptr));
const size_t base_size = message->SpaceUsedLong();
size_t min_expected_size =
sizeof(RepeatedPtrField<std::string>) + base_size;
@ -894,7 +894,7 @@ TEST(ExtensionSetTest, SpaceUsedExcludingSelf) {
// Repeated messages
{
std::unique_ptr<unittest::TestAllExtensions> message(
Arena::CreateMessage<unittest::TestAllExtensions>(nullptr));
Arena::Create<unittest::TestAllExtensions>(nullptr));
const size_t base_size = message->SpaceUsedLong();
size_t min_expected_size =
sizeof(RepeatedPtrField<unittest::ForeignMessage>) + base_size;

7
src/google/protobuf/generated_message_reflection.cc
Unescape View File

@ -2729,11 +2729,10 @@ static Type* AllocIfDefault(const FieldDescriptor* field, Type*& ptr,
if (field->cpp_type() < FieldDescriptor::CPPTYPE_STRING ||
(field->cpp_type() == FieldDescriptor::CPPTYPE_STRING &&
internal::cpp::EffectiveStringCType(field) == FieldOptions::CORD)) {
ptr = reinterpret_cast<Type*>(
Arena::CreateMessage<RepeatedField<int32_t>>(arena));
ptr =
reinterpret_cast<Type*>(Arena::Create<RepeatedField<int32_t>>(arena));
} else {
ptr = reinterpret_cast<Type*>(
Arena::CreateMessage<RepeatedPtrFieldBase>(arena));
ptr = reinterpret_cast<Type*>(Arena::Create<RepeatedPtrFieldBase>(arena));
}
}
return ptr;

53
src/google/protobuf/generated_message_reflection_unittest.cc
Unescape View File

@ -394,9 +394,9 @@ TEST_P(GeneratedMessageReflectionSwapTest, OneofBothSet) {
TEST_P(GeneratedMessageReflectionSwapTest, SwapFields) {
std::unique_ptr<unittest::TestAllTypes> lhs(
Arena::CreateMessage<unittest::TestAllTypes>(nullptr));
Arena::Create<unittest::TestAllTypes>(nullptr));
std::unique_ptr<unittest::TestAllTypes> rhs(
Arena::CreateMessage<unittest::TestAllTypes>(nullptr));
Arena::Create<unittest::TestAllTypes>(nullptr));
lhs->set_optional_double(12.3);
lhs->mutable_repeated_int32()->Add(10);
lhs->mutable_repeated_int32()->Add(20);
@ -432,9 +432,9 @@ TEST_P(GeneratedMessageReflectionSwapTest, SwapFields) {
TEST_P(GeneratedMessageReflectionSwapTest, SwapFieldsAll) {
std::unique_ptr<unittest::TestAllTypes> lhs(
Arena::CreateMessage<unittest::TestAllTypes>(nullptr));
Arena::Create<unittest::TestAllTypes>(nullptr));
std::unique_ptr<unittest::TestAllTypes> rhs(
Arena::CreateMessage<unittest::TestAllTypes>(nullptr));
Arena::Create<unittest::TestAllTypes>(nullptr));
TestUtil::SetAllFields(rhs.get());
@ -449,8 +449,8 @@ TEST_P(GeneratedMessageReflectionSwapTest, SwapFieldsAll) {
TEST(GeneratedMessageReflectionTest, SwapFieldsAllOnDifferentArena) {
Arena arena1, arena2;
auto* message1 = Arena::CreateMessage<unittest::TestAllTypes>(&arena1);
auto* message2 = Arena::CreateMessage<unittest::TestAllTypes>(&arena2);
auto* message1 = Arena::Create<unittest::TestAllTypes>(&arena1);
auto* message2 = Arena::Create<unittest::TestAllTypes>(&arena2);
TestUtil::SetAllFields(message2);
@ -465,9 +465,9 @@ TEST(GeneratedMessageReflectionTest, SwapFieldsAllOnDifferentArena) {
TEST(GeneratedMessageReflectionTest, SwapFieldsAllOnArenaHeap) {
Arena arena;
auto* message1 = Arena::CreateMessage<unittest::TestAllTypes>(&arena);
auto* message1 = Arena::Create<unittest::TestAllTypes>(&arena);
std::unique_ptr<unittest::TestAllTypes> message2(
Arena::CreateMessage<unittest::TestAllTypes>(nullptr));
Arena::Create<unittest::TestAllTypes>(nullptr));
TestUtil::SetAllFields(message2.get());
@ -499,8 +499,8 @@ TEST(GeneratedMessageReflectionTest, SwapFieldsAllExtensionArenaHeap) {
Arena arena;
std::unique_ptr<unittest::TestAllExtensions> message1(
Arena::CreateMessage<unittest::TestAllExtensions>(nullptr));
auto* message2 = Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
Arena::Create<unittest::TestAllExtensions>(nullptr));
auto* message2 = Arena::Create<unittest::TestAllExtensions>(&arena);
TestUtil::SetAllExtensions(message1.get());
@ -515,8 +515,8 @@ TEST(GeneratedMessageReflectionTest, SwapFieldsAllExtensionArenaHeap) {
TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsAll) {
Arena arena;
auto* message1 = Arena::CreateMessage<unittest::TestAllTypes>(&arena);
auto* message2 = Arena::CreateMessage<unittest::TestAllTypes>(&arena);
auto* message1 = Arena::Create<unittest::TestAllTypes>(&arena);
auto* message2 = Arena::Create<unittest::TestAllTypes>(&arena);
TestUtil::SetAllFields(message2);
@ -550,8 +550,8 @@ TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsAll) {
TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsMap) {
Arena arena;
auto* message1 = Arena::CreateMessage<unittest::TestMap>(&arena);
auto* message2 = Arena::CreateMessage<unittest::TestMap>(&arena);
auto* message1 = Arena::Create<unittest::TestMap>(&arena);
auto* message2 = Arena::Create<unittest::TestMap>(&arena);
MapTestUtil::SetMapFields(message2);
@ -574,8 +574,8 @@ TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsMap) {
TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsAllExtension) {
Arena arena;
auto* message1 = Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
auto* message2 = Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
auto* message1 = Arena::Create<unittest::TestAllExtensions>(&arena);
auto* message2 = Arena::Create<unittest::TestAllExtensions>(&arena);
TestUtil::SetAllExtensions(message1);
@ -632,8 +632,8 @@ TEST(GeneratedMessageReflectionTest, SwapFieldsOneof) {
TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsOneof) {
Arena arena;
auto* message1 = Arena::CreateMessage<unittest::TestOneof2>(&arena);
auto* message2 = Arena::CreateMessage<unittest::TestOneof2>(&arena);
auto* message1 = Arena::Create<unittest::TestOneof2>(&arena);
auto* message2 = Arena::Create<unittest::TestOneof2>(&arena);
TestUtil::SetOneof1(message1);
std::vector<const FieldDescriptor*> fields;
@ -651,8 +651,8 @@ TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsOneof) {
TEST(GeneratedMessageReflectionTest,
UnsafeShallowSwapFieldsOneofExpectShallow) {
Arena arena;
auto* message1 = Arena::CreateMessage<unittest::TestOneof2>(&arena);
auto* message2 = Arena::CreateMessage<unittest::TestOneof2>(&arena);
auto* message1 = Arena::Create<unittest::TestOneof2>(&arena);
auto* message2 = Arena::Create<unittest::TestOneof2>(&arena);
TestUtil::SetOneof1(message1);
message1->mutable_foo_message()->set_moo_int(1000);
auto* kept_foo_ptr = message1->mutable_foo_message();
@ -887,7 +887,7 @@ TEST(GeneratedMessageReflectionTest, SetAllocatedMessageOnArenaTest) {
unittest::TestAllTypes from_message2;
Arena arena;
unittest::TestAllTypes* to_message =
Arena::CreateMessage<unittest::TestAllTypes>(&arena);
Arena::Create<unittest::TestAllTypes>(&arena);
TestUtil::ReflectionTester reflection_tester(
unittest::TestAllTypes::descriptor());
reflection_tester.SetAllFieldsViaReflection(&from_message1);
@ -953,7 +953,7 @@ TEST(GeneratedMessageReflectionTest, SetAllocatedExtensionMessageTest) {
TEST(GeneratedMessageReflectionTest, SetAllocatedExtensionMessageOnArenaTest) {
Arena arena;
unittest::TestAllExtensions* to_message =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
Arena::Create<unittest::TestAllExtensions>(&arena);
unittest::TestAllExtensions from_message1;
unittest::TestAllExtensions from_message2;
TestUtil::ReflectionTester reflection_tester(
@ -1185,7 +1185,7 @@ TEST(GeneratedMessageReflectionTest, SetAllocatedOneofMessageOnArenaTest) {
unittest::TestOneof2 from_message2;
Arena arena;
unittest::TestOneof2* to_message =
Arena::CreateMessage<unittest::TestOneof2>(&arena);
Arena::Create<unittest::TestOneof2>(&arena);
const Descriptor* descriptor = unittest::TestOneof2::descriptor();
const Reflection* reflection = to_message->GetReflection();
@ -1310,7 +1310,7 @@ TEST(GeneratedMessageReflectionTest, ReleaseOneofMessageTest) {
TEST(GeneratedMessageReflectionTest, ArenaReleaseMessageTest) {
Arena arena;
unittest::TestAllTypes* message =
Arena::CreateMessage<unittest::TestAllTypes>(&arena);
Arena::Create<unittest::TestAllTypes>(&arena);
TestUtil::ReflectionTester reflection_tester(
unittest::TestAllTypes::descriptor());
@ -1334,7 +1334,7 @@ TEST(GeneratedMessageReflectionTest, ArenaReleaseMessageTest) {
TEST(GeneratedMessageReflectionTest, ArenaReleaseExtensionMessageTest) {
Arena arena;
unittest::TestAllExtensions* message =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena);
Arena::Create<unittest::TestAllExtensions>(&arena);
TestUtil::ReflectionTester reflection_tester(
unittest::TestAllExtensions::descriptor());
@ -1357,8 +1357,7 @@ TEST(GeneratedMessageReflectionTest, ArenaReleaseExtensionMessageTest) {
TEST(GeneratedMessageReflectionTest, ArenaReleaseOneofMessageTest) {
Arena arena;
unittest::TestOneof2* message =
Arena::CreateMessage<unittest::TestOneof2>(&arena);
unittest::TestOneof2* message = Arena::Create<unittest::TestOneof2>(&arena);
TestUtil::ReflectionTester::SetOneofViaReflection(message);
const Descriptor* descriptor = unittest::TestOneof2::descriptor();

2
src/google/protobuf/generated_message_tctable_impl.h
Unescape View File

@ -612,7 +612,7 @@ class PROTOBUF_EXPORT TcParser final {
if (!is_split) return RefAt<T>(x, offset);
void*& ptr = RefAt<void*>(x, offset);
if (ptr == DefaultRawPtr()) {
ptr = Arena::CreateMessage<T>(msg->GetArena());
ptr = Arena::Create<T>(msg->GetArena());
}
return *static_cast<T*>(ptr);
}

2
src/google/protobuf/implicit_weak_message.h
Unescape View File

@ -59,7 +59,7 @@ class PROTOBUF_EXPORT ImplicitWeakMessage : public MessageLite {
const ClassData* GetClassData() const final;
MessageLite* New(Arena* arena) const override {
return Arena::CreateMessage<ImplicitWeakMessage>(arena);
return Arena::Create<ImplicitWeakMessage>(arena);
}
void Clear() override { data_->clear(); }

7
src/google/protobuf/lite_arena_unittest.cc
Unescape View File

@ -38,12 +38,12 @@ TEST_F(LiteArenaTest, MapNoHeapAllocation) {
// internal::NoHeapChecker no_heap;
protobuf_unittest::TestArenaMapLite* from =
Arena::CreateMessage<protobuf_unittest::TestArenaMapLite>(arena_.get());
Arena::Create<protobuf_unittest::TestArenaMapLite>(arena_.get());
MapLiteTestUtil::SetArenaMapFields(from);
from->SerializeToString(&data);
protobuf_unittest::TestArenaMapLite* to =
Arena::CreateMessage<protobuf_unittest::TestArenaMapLite>(arena_.get());
Arena::Create<protobuf_unittest::TestArenaMapLite>(arena_.get());
to->ParseFromString(data);
MapLiteTestUtil::ExpectArenaMapFieldsSet(*to);
}
@ -51,8 +51,7 @@ TEST_F(LiteArenaTest, MapNoHeapAllocation) {
TEST_F(LiteArenaTest, UnknownFieldMemLeak) {
protobuf_unittest::ForeignMessageArenaLite* message =
Arena::CreateMessage<protobuf_unittest::ForeignMessageArenaLite>(
arena_.get());
Arena::Create<protobuf_unittest::ForeignMessageArenaLite>(arena_.get());
std::string data = "\012\000";
int original_capacity = data.capacity();
while (data.capacity() <= original_capacity) {

2
src/google/protobuf/lite_unittest.cc
Unescape View File

@ -1095,7 +1095,7 @@ TYPED_TEST(LiteTest, AllLite47) {
TYPED_TEST(LiteTest, MapCrash) {
// See b/113635730
Arena arena;
auto msg = Arena::CreateMessage<protobuf_unittest::TestMapLite>(&arena);
auto msg = Arena::Create<protobuf_unittest::TestMapLite>(&arena);
// Payload for the map<string, Enum> with a enum varint that's longer >
// 10 bytes. This causes a parse fail and a subsequent delete. field 16
// (map<int32, MapEnumLite>) tag = 128+2 = \202 \1

2
src/google/protobuf/map_entry.h
Unescape View File

@ -108,7 +108,7 @@ class MapEntry : public Message {
using DestructorSkippable_ = void;
Message* New(Arena* arena) const final {
return Arena::CreateMessage<Derived>(arena);
return Arena::Create<Derived>(arena);
}
protected:

2
src/google/protobuf/map_field.h
Unescape View File

@ -671,7 +671,7 @@ class MapField final : public TypeDefinedMapFieldBase<Key, T> {
// Used in the implementation of parsing. Caller should take the ownership iff
// arena_ is nullptr.
EntryType* NewEntry() const {
return Arena::CreateMessage<EntryType>(this->arena());
return Arena::Create<EntryType>(this->arena());
}
private:

7
src/google/protobuf/map_field_test.cc
Unescape View File

@ -135,7 +135,7 @@ TEST_P(MapFieldBasePrimitiveTest, Arena) {
// repeated fields are allocated from arenas.
// NoHeapChecker no_heap;
MapFieldType* map_field = Arena::CreateMessage<MapFieldType>(&arena);
MapFieldType* map_field = Arena::Create<MapFieldType>(&arena);
// Set content in map
(*map_field->MutableMap())[100] = 101;
@ -149,7 +149,7 @@ TEST_P(MapFieldBasePrimitiveTest, Arena) {
// repeated fields are allocated from arenas.
// NoHeapChecker no_heap;
TestMapField* map_field = Arena::CreateMessage<TestMapField>(&arena);
TestMapField* map_field = Arena::Create<TestMapField>(&arena);
// Trigger conversion to repeated field.
EXPECT_TRUE(map_field->MutableRepeatedField() != nullptr);
@ -160,8 +160,7 @@ TEST_P(MapFieldBasePrimitiveTest, Arena) {
}
TEST_P(MapFieldBasePrimitiveTest, EnforceNoArena) {
std::unique_ptr<TestMapField> map_field(
Arena::CreateMessage<TestMapField>(nullptr));
std::unique_ptr<TestMapField> map_field(Arena::Create<TestMapField>(nullptr));
EXPECT_EQ(MapFieldTestPeer::GetArena(map_field->GetRepeatedField()), nullptr);
}

2
src/google/protobuf/map_test.cc
Unescape View File

@ -242,7 +242,7 @@ TEST(MapTest, NaturalGrowthOnArenasReuseBlocks) {
static constexpr int kNumFields = 100;
static constexpr int kNumElems = 1000;
for (int i = 0; i < kNumFields; ++i) {
values.push_back(Arena::CreateMessage<Map<int, int>>(&arena));
values.push_back(Arena::Create<Map<int, int>>(&arena));
auto& field = *values.back();
for (int j = 0; j < kNumElems; ++j) {
field[j] = j;

17
src/google/protobuf/map_test.inc
Unescape View File

@ -1252,7 +1252,7 @@ TEST_F(MapImplTest, SwapFieldArenaReflection) {
{
// Use local_arena to allocate lhs to trigger use-after-free error.
Arena local_arena;
auto* lhs = Arena::CreateMessage<TestMap>(&local_arena);
auto* lhs = Arena::Create<TestMap>(&local_arena);
const auto* reflection = lhs->GetReflection();
std::vector<const FieldDescriptor*> fields;
@ -4080,12 +4080,11 @@ TEST(ArenaTest, ParsingAndSerializingNoHeapAllocation) {
// NoHeapChecker no_heap;
UNITTEST::TestArenaMap* from =
Arena::CreateMessage<UNITTEST::TestArenaMap>(&arena);
Arena::Create<UNITTEST::TestArenaMap>(&arena);
MapTestUtil::SetArenaMapFields(from);
from->SerializeToString(&data);
UNITTEST::TestArenaMap* to =
Arena::CreateMessage<UNITTEST::TestArenaMap>(&arena);
UNITTEST::TestArenaMap* to = Arena::Create<UNITTEST::TestArenaMap>(&arena);
to->ParseFromString(data);
MapTestUtil::ExpectArenaMapFieldsSet(*to);
}
@ -4108,10 +4107,8 @@ TEST(ArenaTest, ReflectionInTextFormat) {
TextFormat::Printer printer;
TextFormat::Parser parser;
UNITTEST::TestArenaMap* from =
Arena::CreateMessage<UNITTEST::TestArenaMap>(&arena);
UNITTEST::TestArenaMap* to =
Arena::CreateMessage<UNITTEST::TestArenaMap>(&arena);
UNITTEST::TestArenaMap* from = Arena::Create<UNITTEST::TestArenaMap>(&arena);
UNITTEST::TestArenaMap* to = Arena::Create<UNITTEST::TestArenaMap>(&arena);
MapTestUtil::SetArenaMapFields(from);
printer.PrintToString(*from, &data);
@ -4124,7 +4121,7 @@ TEST(ArenaTest, ReflectionInTextFormat) {
TEST(ArenaTest, StringMapNoLeak) {
Arena arena;
UNITTEST::TestArenaMap* message =
Arena::CreateMessage<UNITTEST::TestArenaMap>(&arena);
Arena::Create<UNITTEST::TestArenaMap>(&arena);
std::string data;
// String with length less than 16 will not be allocated from heap.
int original_capacity = data.capacity();
@ -4154,7 +4151,7 @@ TEST(ArenaTest, IsInitialized) {
Arena arena(options);
UNITTEST::TestArenaMap* message =
Arena::CreateMessage<UNITTEST::TestArenaMap>(&arena);
Arena::Create<UNITTEST::TestArenaMap>(&arena);
EXPECT_EQ(0, (*message->mutable_map_int32_int32())[0]);
}

9
src/google/protobuf/message_unittest.inc
Unescape View File

@ -724,13 +724,13 @@ TEST(MESSAGE_TEST_NAME, Swap) {
{
Arena arena;
UNITTEST::NestedTestAllTypes* p1 =
Arena::CreateMessage<UNITTEST::NestedTestAllTypes>(&arena);
Arena::Create<UNITTEST::NestedTestAllTypes>(&arena);
// Should parse correctly.
EXPECT_TRUE(p1->ParseFromString(serialized));
UNITTEST::NestedTestAllTypes* p2 =
Arena::CreateMessage<UNITTEST::NestedTestAllTypes>(&arena);
Arena::Create<UNITTEST::NestedTestAllTypes>(&arena);
p1->Swap(p2);
@ -1016,7 +1016,7 @@ TEST(MESSAGE_TEST_NAME, MessageIsStillValidAfterParseFails) {
{
Arena arena;
UNITTEST::TestAllTypes* arena_message =
Arena::CreateMessage<UNITTEST::TestAllTypes>(&arena);
Arena::Create<UNITTEST::TestAllTypes>(&arena);
EXPECT_FALSE(arena_message->ParseFromString(invalid_string_data));
arena_message->Clear();
EXPECT_EQ("", arena_message->optional_string());
@ -1994,8 +1994,7 @@ TEST(MESSAGE_TEST_NAME, TestRegressionOverwrittenLazyOneofDoesNotLeak) {
// This call had a bug where the LazyField was not destroyed in any way
// causing the Cord inside it to leak its contents.
EXPECT_TRUE(
Arena::CreateMessage<UNITTEST::TestAllTypes>(&arena)->ParseFromString(
str));
Arena::Create<UNITTEST::TestAllTypes>(&arena)->ParseFromString(str));
}
} // namespace protobuf

4
src/google/protobuf/message_unittest_legacy_apis.inc
Unescape View File

@ -156,12 +156,12 @@ TEST(MESSAGE_TEST_NAME, TestRegressionInlinedStringAuxIdxMismatchOnFastParser) {
encoded = proto.SerializeAsString();
}
Arena arena;
auto* proto = Arena::CreateMessage<Proto>(&arena);
auto* proto = Arena::Create<Proto>(&arena);
// We don't alter donation here, so it works even if the idx are bad.
ASSERT_TRUE(proto->ParseFromString(encoded));
// Now we alter donation bits. str2's bit (#2) will be off, but its aux_idx
// (#3) will point to a donated string.
proto = Arena::CreateMessage<Proto>(&arena);
proto = Arena::Create<Proto>(&arena);
proto->mutable_str1();
proto->mutable_str2();
proto->mutable_str3();

10
src/google/protobuf/proto3_arena_lite_unittest.cc
Unescape View File

@ -88,7 +88,7 @@ TEST(Proto3ArenaLiteTest, Parsing) {
SetAllFields(&original);
Arena arena;
TestAllTypes* arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
TestAllTypes* arena_message = Arena::Create<TestAllTypes>(&arena);
arena_message->ParseFromString(original.SerializeAsString());
ExpectAllFieldsSet(*arena_message);
}
@ -98,8 +98,8 @@ TEST(Proto3ArenaLiteTest, Swap) {
Arena arena2;
// Test Swap().
TestAllTypes* arena1_message = Arena::CreateMessage<TestAllTypes>(&arena1);
TestAllTypes* arena2_message = Arena::CreateMessage<TestAllTypes>(&arena2);
TestAllTypes* arena1_message = Arena::Create<TestAllTypes>(&arena1);
TestAllTypes* arena2_message = Arena::Create<TestAllTypes>(&arena2);
arena1_message->Swap(arena2_message);
EXPECT_EQ(&arena1, arena1_message->GetArena());
EXPECT_EQ(&arena2, arena2_message->GetArena());
@ -107,7 +107,7 @@ TEST(Proto3ArenaLiteTest, Swap) {
TEST(Proto3ArenaLiteTest, SetAllocatedMessage) {
Arena arena;
TestAllTypes* arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
TestAllTypes* arena_message = Arena::Create<TestAllTypes>(&arena);
TestAllTypes::NestedMessage* nested = new TestAllTypes::NestedMessage;
nested->set_bb(118);
arena_message->set_allocated_optional_nested_message(nested);
@ -116,7 +116,7 @@ TEST(Proto3ArenaLiteTest, SetAllocatedMessage) {
TEST(Proto3ArenaLiteTest, ReleaseMessage) {
Arena arena;
TestAllTypes* arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
TestAllTypes* arena_message = Arena::Create<TestAllTypes>(&arena);
arena_message->mutable_optional_nested_message()->set_bb(118);
std::unique_ptr<TestAllTypes::NestedMessage> nested(
arena_message->release_optional_nested_message());

24
src/google/protobuf/proto3_arena_unittest.cc
Unescape View File

@ -100,7 +100,7 @@ TEST(Proto3ArenaTest, Parsing) {
SetAllFields(&original);
Arena arena;
TestAllTypes* arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
TestAllTypes* arena_message = Arena::Create<TestAllTypes>(&arena);
arena_message->ParseFromString(original.SerializeAsString());
ExpectAllFieldsSet(*arena_message);
}
@ -110,7 +110,7 @@ TEST(Proto3ArenaTest, UnknownFields) {
SetAllFields(&original);
Arena arena;
TestAllTypes* arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
TestAllTypes* arena_message = Arena::Create<TestAllTypes>(&arena);
arena_message->ParseFromString(original.SerializeAsString());
ExpectAllFieldsSet(*arena_message);
@ -130,7 +130,7 @@ TEST(Proto3ArenaTest, GetArena) {
Arena arena;
// Tests arena-allocated message and submessages.
auto* arena_message1 = Arena::CreateMessage<TestAllTypes>(&arena);
auto* arena_message1 = Arena::Create<TestAllTypes>(&arena);
auto* arena_submessage1 = arena_message1->mutable_optional_foreign_message();
auto* arena_repeated_submessage1 =
arena_message1->add_repeated_foreign_message();
@ -139,7 +139,7 @@ TEST(Proto3ArenaTest, GetArena) {
EXPECT_EQ(&arena, arena_repeated_submessage1->GetArena());
// Tests attached heap-allocated messages.
auto* arena_message2 = Arena::CreateMessage<TestAllTypes>(&arena);
auto* arena_message2 = Arena::Create<TestAllTypes>(&arena);
arena_message2->set_allocated_optional_foreign_message(new ForeignMessage());
arena_message2->mutable_repeated_foreign_message()->AddAllocated(
new ForeignMessage());
@ -158,7 +158,7 @@ TEST(Proto3ArenaTest, GetArenaWithUnknown) {
Arena arena;
// Tests arena-allocated message and submessages.
auto* arena_message1 = Arena::CreateMessage<TestAllTypes>(&arena);
auto* arena_message1 = Arena::Create<TestAllTypes>(&arena);
arena_message1->GetReflection()->MutableUnknownFields(arena_message1);
auto* arena_submessage1 = arena_message1->mutable_optional_foreign_message();
arena_submessage1->GetReflection()->MutableUnknownFields(arena_submessage1);
@ -171,7 +171,7 @@ TEST(Proto3ArenaTest, GetArenaWithUnknown) {
EXPECT_EQ(&arena, arena_repeated_submessage1->GetArena());
// Tests attached heap-allocated messages.
auto* arena_message2 = Arena::CreateMessage<TestAllTypes>(&arena);
auto* arena_message2 = Arena::Create<TestAllTypes>(&arena);
arena_message2->set_allocated_optional_foreign_message(new ForeignMessage());
arena_message2->mutable_repeated_foreign_message()->AddAllocated(
new ForeignMessage());
@ -190,8 +190,8 @@ TEST(Proto3ArenaTest, Swap) {
Arena arena2;
// Test Swap().
TestAllTypes* arena1_message = Arena::CreateMessage<TestAllTypes>(&arena1);
TestAllTypes* arena2_message = Arena::CreateMessage<TestAllTypes>(&arena2);
TestAllTypes* arena1_message = Arena::Create<TestAllTypes>(&arena1);
TestAllTypes* arena2_message = Arena::Create<TestAllTypes>(&arena2);
arena1_message->Swap(arena2_message);
EXPECT_EQ(&arena1, arena1_message->GetArena());
EXPECT_EQ(&arena2, arena2_message->GetArena());
@ -199,7 +199,7 @@ TEST(Proto3ArenaTest, Swap) {
TEST(Proto3ArenaTest, SetAllocatedMessage) {
Arena arena;
TestAllTypes* arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
TestAllTypes* arena_message = Arena::Create<TestAllTypes>(&arena);
TestAllTypes::NestedMessage* nested = new TestAllTypes::NestedMessage;
nested->set_bb(118);
arena_message->set_allocated_optional_nested_message(nested);
@ -208,7 +208,7 @@ TEST(Proto3ArenaTest, SetAllocatedMessage) {
TEST(Proto3ArenaTest, ReleaseMessage) {
Arena arena;
TestAllTypes* arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
TestAllTypes* arena_message = Arena::Create<TestAllTypes>(&arena);
arena_message->mutable_optional_nested_message()->set_bb(118);
std::unique_ptr<TestAllTypes::NestedMessage> nested(
arena_message->release_optional_nested_message());
@ -218,7 +218,7 @@ TEST(Proto3ArenaTest, ReleaseMessage) {
TEST(Proto3ArenaTest, MessageFieldClear) {
// GitHub issue #310: https://github.com/protocolbuffers/protobuf/issues/310
Arena arena;
TestAllTypes* arena_message = Arena::CreateMessage<TestAllTypes>(&arena);
TestAllTypes* arena_message = Arena::Create<TestAllTypes>(&arena);
arena_message->mutable_optional_nested_message()->set_bb(118);
// This should not crash, but prior to the bugfix, it tried to use `operator
// delete` the nested message (which is on the arena):
@ -227,7 +227,7 @@ TEST(Proto3ArenaTest, MessageFieldClear) {
TEST(Proto3ArenaTest, MessageFieldClearViaReflection) {
Arena arena;
TestAllTypes* message = Arena::CreateMessage<TestAllTypes>(&arena);
TestAllTypes* message = Arena::Create<TestAllTypes>(&arena);
const Reflection* r = message->GetReflection();
const Descriptor* d = message->GetDescriptor();
const FieldDescriptor* msg_field =

4
src/google/protobuf/reflection_ops_unittest.cc
Unescape View File

@ -488,7 +488,7 @@ TEST(ReflectionOpsTest, GenericSwap) {
Arena arena;
{
unittest::TestAllTypes message;
auto* arena_message = Arena::CreateMessage<unittest::TestAllTypes>(&arena);
auto* arena_message = Arena::Create<unittest::TestAllTypes>(&arena);
TestUtil::SetAllFields(arena_message);
const uint64_t initial_arena_size = arena.SpaceUsed();
@ -501,7 +501,7 @@ TEST(ReflectionOpsTest, GenericSwap) {
}
{
unittest::TestAllTypes message;
auto* arena_message = Arena::CreateMessage<unittest::TestAllTypes>(&arena);
auto* arena_message = Arena::Create<unittest::TestAllTypes>(&arena);
TestUtil::SetAllFields(arena_message);
const uint64_t initial_arena_size = arena.SpaceUsed();

76
src/google/protobuf/repeated_field_unittest.cc
Unescape View File

@ -237,7 +237,7 @@ void CheckAllocationSizes(bool is_ptr) {
std::string buf(1 << 20, 0);
Arena arena(&buf[0], buf.size());
auto* rep = Arena::CreateMessage<Rep>(&arena);
auto* rep = Arena::Create<Rep>(&arena);
size_t prev = arena.SpaceUsed();
for (int i = 0; i < 100; ++i) {
@ -283,7 +283,7 @@ TEST(RepeatedField, NaturalGrowthOnArenasReuseBlocks) {
static constexpr int kNumFields = 100;
static constexpr int kNumElems = 1000;
for (int i = 0; i < kNumFields; ++i) {
values.push_back(Arena::CreateMessage<RepeatedField<int>>(&arena));
values.push_back(Arena::Create<RepeatedField<int>>(&arena));
auto& field = *values.back();
for (int j = 0; j < kNumElems; ++j) {
field.Add(j);
@ -908,8 +908,7 @@ TEST(RepeatedField, MoveConstruct) {
}
{
Arena arena;
RepeatedField<int>* source =
Arena::CreateMessage<RepeatedField<int>>(&arena);
RepeatedField<int>* source = Arena::Create<RepeatedField<int>>(&arena);
source->Add(1);
source->Add(2);
RepeatedField<int> destination = std::move(*source);
@ -940,12 +939,10 @@ TEST(RepeatedField, MoveAssign) {
}
{
Arena arena;
RepeatedField<int>* source =
Arena::CreateMessage<RepeatedField<int>>(&arena);
RepeatedField<int>* source = Arena::Create<RepeatedField<int>>(&arena);
source->Add(1);
source->Add(2);
RepeatedField<int>* destination =
Arena::CreateMessage<RepeatedField<int>>(&arena);
RepeatedField<int>* destination = Arena::Create<RepeatedField<int>>(&arena);
destination->Add(3);
const int* source_data = source->data();
*destination = std::move(*source);
@ -956,12 +953,12 @@ TEST(RepeatedField, MoveAssign) {
{
Arena source_arena;
RepeatedField<int>* source =
Arena::CreateMessage<RepeatedField<int>>(&source_arena);
Arena::Create<RepeatedField<int>>(&source_arena);
source->Add(1);
source->Add(2);
Arena destination_arena;
RepeatedField<int>* destination =
Arena::CreateMessage<RepeatedField<int>>(&destination_arena);
Arena::Create<RepeatedField<int>>(&destination_arena);
destination->Add(3);
*destination = std::move(*source);
EXPECT_THAT(*destination, ElementsAre(1, 2));
@ -971,8 +968,7 @@ TEST(RepeatedField, MoveAssign) {
}
{
Arena arena;
RepeatedField<int>* source =
Arena::CreateMessage<RepeatedField<int>>(&arena);
RepeatedField<int>* source = Arena::Create<RepeatedField<int>>(&arena);
source->Add(1);
source->Add(2);
RepeatedField<int> destination;
@ -988,8 +984,7 @@ TEST(RepeatedField, MoveAssign) {
source.Add(1);
source.Add(2);
Arena arena;
RepeatedField<int>* destination =
Arena::CreateMessage<RepeatedField<int>>(&arena);
RepeatedField<int>* destination = Arena::Create<RepeatedField<int>>(&arena);
destination->Add(3);
*destination = std::move(source);
EXPECT_THAT(*destination, ElementsAre(1, 2));
@ -1010,8 +1005,7 @@ TEST(RepeatedField, MoveAssign) {
}
{
Arena arena;
RepeatedField<int>* field =
Arena::CreateMessage<RepeatedField<int>>(&arena);
RepeatedField<int>* field = Arena::Create<RepeatedField<int>>(&arena);
field->Add(1);
field->Add(2);
const int* data = field->data();
@ -1342,13 +1336,12 @@ TEST(RepeatedField, PoisonsMemoryOnAssign) {
TEST(RepeatedField, Cleanups) {
Arena arena;
auto growth = internal::CleanupGrowth(
arena, [&] { Arena::CreateMessage<RepeatedField<int>>(&arena); });
arena, [&] { Arena::Create<RepeatedField<int>>(&arena); });
EXPECT_THAT(growth.cleanups, testing::IsEmpty());
void* ptr;
growth = internal::CleanupGrowth(arena, [&] {
ptr = Arena::CreateMessage<RepeatedField<absl::Cord>>(&arena);
});
growth = internal::CleanupGrowth(
arena, [&] { ptr = Arena::Create<RepeatedField<absl::Cord>>(&arena); });
EXPECT_THAT(growth.cleanups, testing::UnorderedElementsAre(ptr));
}
@ -1496,7 +1489,7 @@ TEST(RepeatedPtrField, NaturalGrowthOnArenasReuseBlocks) {
static constexpr int kNumFields = 100;
static constexpr int kNumElems = 1000;
for (int i = 0; i < kNumFields; ++i) {
values.push_back(Arena::CreateMessage<Rep>(&arena));
values.push_back(Arena::Create<Rep>(&arena));
auto& field = *values.back();
for (int j = 0; j < kNumElems; ++j) {
field.Add("");
@ -1760,7 +1753,7 @@ TEST(RepeatedPtrField, AddMethodsDontAcceptNull) {
TEST(RepeatedPtrField, AddAllocatedDifferentArena) {
RepeatedPtrField<TestAllTypes> field;
Arena arena;
auto* msg = Arena::CreateMessage<TestAllTypes>(&arena);
auto* msg = Arena::Create<TestAllTypes>(&arena);
field.AddAllocated(msg);
}
@ -1911,7 +1904,7 @@ TEST(RepeatedPtrField, SmallOptimization) {
// We use an arena to easily measure memory usage, but not needed.
Arena arena;
auto* array = Arena::CreateMessage<RepeatedPtrField<std::string>>(&arena);
auto* array = Arena::Create<RepeatedPtrField<std::string>>(&arena);
EXPECT_EQ(array->Capacity(), 1);
EXPECT_EQ(array->SpaceUsedExcludingSelf(), 0);
std::string str;
@ -1992,7 +1985,7 @@ TEST(RepeatedPtrField, MoveConstruct) {
{
Arena arena;
RepeatedPtrField<std::string>* source =
Arena::CreateMessage<RepeatedPtrField<std::string>>(&arena);
Arena::Create<RepeatedPtrField<std::string>>(&arena);
*source->Add() = "1";
*source->Add() = "2";
RepeatedPtrField<std::string> destination = std::move(*source);
@ -2020,11 +2013,11 @@ TEST(RepeatedPtrField, MoveAssign) {
{
Arena arena;
RepeatedPtrField<std::string>* source =
Arena::CreateMessage<RepeatedPtrField<std::string>>(&arena);
Arena::Create<RepeatedPtrField<std::string>>(&arena);
*source->Add() = "1";
*source->Add() = "2";
RepeatedPtrField<std::string>* destination =
Arena::CreateMessage<RepeatedPtrField<std::string>>(&arena);
Arena::Create<RepeatedPtrField<std::string>>(&arena);
*destination->Add() = "3";
const std::string* const* source_data = source->data();
*destination = std::move(*source);
@ -2035,12 +2028,12 @@ TEST(RepeatedPtrField, MoveAssign) {
{
Arena source_arena;
RepeatedPtrField<std::string>* source =
Arena::CreateMessage<RepeatedPtrField<std::string>>(&source_arena);
Arena::Create<RepeatedPtrField<std::string>>(&source_arena);
*source->Add() = "1";
*source->Add() = "2";
Arena destination_arena;
RepeatedPtrField<std::string>* destination =
Arena::CreateMessage<RepeatedPtrField<std::string>>(&destination_arena);
Arena::Create<RepeatedPtrField<std::string>>(&destination_arena);
*destination->Add() = "3";
*destination = std::move(*source);
EXPECT_THAT(*destination, ElementsAre("1", "2"));
@ -2051,7 +2044,7 @@ TEST(RepeatedPtrField, MoveAssign) {
{
Arena arena;
RepeatedPtrField<std::string>* source =
Arena::CreateMessage<RepeatedPtrField<std::string>>(&arena);
Arena::Create<RepeatedPtrField<std::string>>(&arena);
*source->Add() = "1";
*source->Add() = "2";
RepeatedPtrField<std::string> destination;
@ -2068,7 +2061,7 @@ TEST(RepeatedPtrField, MoveAssign) {
*source.Add() = "2";
Arena arena;
RepeatedPtrField<std::string>* destination =
Arena::CreateMessage<RepeatedPtrField<std::string>>(&arena);
Arena::Create<RepeatedPtrField<std::string>>(&arena);
*destination->Add() = "3";
*destination = std::move(source);
EXPECT_THAT(*destination, ElementsAre("1", "2"));
@ -2090,7 +2083,7 @@ TEST(RepeatedPtrField, MoveAssign) {
{
Arena arena;
RepeatedPtrField<std::string>* field =
Arena::CreateMessage<RepeatedPtrField<std::string>>(&arena);
Arena::Create<RepeatedPtrField<std::string>>(&arena);
*field->Add() = "1";
*field->Add() = "2";
const std::string* const* data = field->data();
@ -2133,8 +2126,7 @@ TEST(RepeatedPtrField, ExtractSubrange) {
// Create an array with "sz" elements and "extra" cleared elements.
// Use an arena to avoid copies from debug-build stability checks.
Arena arena;
auto& field =
*Arena::CreateMessage<RepeatedPtrField<std::string>>(&arena);
auto& field = *Arena::Create<RepeatedPtrField<std::string>>(&arena);
for (int i = 0; i < sz + extra; ++i) {
subject.push_back(new std::string());
field.AddAllocated(subject[i]);
@ -2192,14 +2184,12 @@ TEST(RepeatedPtrField, DeleteSubrange) {
TEST(RepeatedPtrField, Cleanups) {
Arena arena;
auto growth = internal::CleanupGrowth(arena, [&] {
Arena::CreateMessage<RepeatedPtrField<std::string>>(&arena);
});
auto growth = internal::CleanupGrowth(
arena, [&] { Arena::Create<RepeatedPtrField<std::string>>(&arena); });
EXPECT_THAT(growth.cleanups, testing::IsEmpty());
growth = internal::CleanupGrowth(arena, [&] {
Arena::CreateMessage<RepeatedPtrField<TestAllTypes>>(&arena);
});
growth = internal::CleanupGrowth(
arena, [&] { Arena::Create<RepeatedPtrField<TestAllTypes>>(&arena); });
EXPECT_THAT(growth.cleanups, testing::IsEmpty());
}
@ -2800,13 +2790,13 @@ TEST_F(RepeatedFieldInsertionIteratorsTest,
UnsafeArenaAllocatedRepeatedPtrFieldWithStringIntData) {
std::vector<Nested*> data;
Arena arena;
auto* goldenproto = Arena::CreateMessage<TestAllTypes>(&arena);
auto* goldenproto = Arena::Create<TestAllTypes>(&arena);
for (int i = 0; i < 10; ++i) {
auto* new_data = goldenproto->add_repeated_nested_message();
new_data->set_bb(i);
data.push_back(new_data);
}
auto* testproto = Arena::CreateMessage<TestAllTypes>(&arena);
auto* testproto = Arena::Create<TestAllTypes>(&arena);
std::copy(data.begin(), data.end(),
UnsafeArenaAllocatedRepeatedPtrFieldBackInserter(
testproto->mutable_repeated_nested_message()));
@ -2817,13 +2807,13 @@ TEST_F(RepeatedFieldInsertionIteratorsTest,
UnsafeArenaAllocatedRepeatedPtrFieldWithString) {
std::vector<std::string*> data;
Arena arena;
auto* goldenproto = Arena::CreateMessage<TestAllTypes>(&arena);
auto* goldenproto = Arena::Create<TestAllTypes>(&arena);
for (int i = 0; i < 10; ++i) {
auto* new_data = goldenproto->add_repeated_string();
*new_data = absl::StrCat("name-", i);
data.push_back(new_data);
}
auto* testproto = Arena::CreateMessage<TestAllTypes>(&arena);
auto* testproto = Arena::Create<TestAllTypes>(&arena);
std::copy(data.begin(), data.end(),
UnsafeArenaAllocatedRepeatedPtrFieldBackInserter(
testproto->mutable_repeated_string()));

Write Preview
Loading…
Cancel
Save