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
Unified 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)) { for (int c = 1 + (i % 17); c < 256; c += 2 * c + (i & 3)) {
s[i] ^= c; s[i] ^= c;
Arena arena; Arena arena;
T* message = Arena::CreateMessage<T>(use_arena ? &arena : nullptr); T* message = Arena::Create<T>(use_arena ? &arena : nullptr);
if (message->ParseFromString(s)) { if (message->ParseFromString(s)) {
++success_count; ++success_count;
} }
@ -118,8 +118,7 @@ template <typename T>
class ArenaHolder { class ArenaHolder {
public: public:
explicit ArenaHolder(Arena* arena) explicit ArenaHolder(Arena* arena)
: field_(Arena::CreateMessage<T>(arena)), : field_(Arena::Create<T>(arena)), owned_by_arena_(arena != nullptr) {
owned_by_arena_(arena != nullptr) {
ABSL_DCHECK(google::protobuf::Arena::is_arena_constructable<T>::value); ABSL_DCHECK(google::protobuf::Arena::is_arena_constructable<T>::value);
ABSL_DCHECK(google::protobuf::Arena::is_destructor_skippable<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(); encoded = proto.SerializeAsString();
} }
Arena arena; 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. // We don't alter donation here, so it works even if the idx are bad.
ASSERT_TRUE(proto->ParseFromString(encoded)); ASSERT_TRUE(proto->ParseFromString(encoded));
// Now we alter donation bits. str2's bit (#2) will be off, but its aux_idx // Now we alter donation bits. str2's bit (#2) will be off, but its aux_idx
// (#3) will point to a donated string. // (#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 // String view fields don't allow mutable accessors which obviate the needs
// for donation tracker. We will clean up the internal logic after migration // for donation tracker. We will clean up the internal logic after migration
// to string view fields matures. // 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_repeated = true; \
extension->is_packed = packed; \ extension->is_packed = packed; \
extension->repeated_##LOWERCASE##_value = \ extension->repeated_##LOWERCASE##_value = \
Arena::CreateMessage<RepeatedField<LOWERCASE>>(arena_); \ Arena::Create<RepeatedField<LOWERCASE>>(arena_); \
} else { \ } else { \
ABSL_DCHECK_TYPE(*extension, REPEATED_FIELD, UPPERCASE); \ ABSL_DCHECK_TYPE(*extension, REPEATED_FIELD, UPPERCASE); \
ABSL_DCHECK_EQ(extension->is_packed, packed); \ 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))) { static_cast<WireFormatLite::FieldType>(field_type))) {
case WireFormatLite::CPPTYPE_INT32: case WireFormatLite::CPPTYPE_INT32:
extension->repeated_int32_t_value = extension->repeated_int32_t_value =
Arena::CreateMessage<RepeatedField<int32_t>>(arena_); Arena::Create<RepeatedField<int32_t>>(arena_);
break; break;
case WireFormatLite::CPPTYPE_INT64: case WireFormatLite::CPPTYPE_INT64:
extension->repeated_int64_t_value = extension->repeated_int64_t_value =
Arena::CreateMessage<RepeatedField<int64_t>>(arena_); Arena::Create<RepeatedField<int64_t>>(arena_);
break; break;
case WireFormatLite::CPPTYPE_UINT32: case WireFormatLite::CPPTYPE_UINT32:
extension->repeated_uint32_t_value = extension->repeated_uint32_t_value =
Arena::CreateMessage<RepeatedField<uint32_t>>(arena_); Arena::Create<RepeatedField<uint32_t>>(arena_);
break; break;
case WireFormatLite::CPPTYPE_UINT64: case WireFormatLite::CPPTYPE_UINT64:
extension->repeated_uint64_t_value = extension->repeated_uint64_t_value =
Arena::CreateMessage<RepeatedField<uint64_t>>(arena_); Arena::Create<RepeatedField<uint64_t>>(arena_);
break; break;
case WireFormatLite::CPPTYPE_DOUBLE: case WireFormatLite::CPPTYPE_DOUBLE:
extension->repeated_double_value = extension->repeated_double_value =
Arena::CreateMessage<RepeatedField<double>>(arena_); Arena::Create<RepeatedField<double>>(arena_);
break; break;
case WireFormatLite::CPPTYPE_FLOAT: case WireFormatLite::CPPTYPE_FLOAT:
extension->repeated_float_value = extension->repeated_float_value =
Arena::CreateMessage<RepeatedField<float>>(arena_); Arena::Create<RepeatedField<float>>(arena_);
break; break;
case WireFormatLite::CPPTYPE_BOOL: case WireFormatLite::CPPTYPE_BOOL:
extension->repeated_bool_value = extension->repeated_bool_value =
Arena::CreateMessage<RepeatedField<bool>>(arena_); Arena::Create<RepeatedField<bool>>(arena_);
break; break;
case WireFormatLite::CPPTYPE_ENUM: case WireFormatLite::CPPTYPE_ENUM:
extension->repeated_enum_value = extension->repeated_enum_value =
Arena::CreateMessage<RepeatedField<int>>(arena_); Arena::Create<RepeatedField<int>>(arena_);
break; break;
case WireFormatLite::CPPTYPE_STRING: case WireFormatLite::CPPTYPE_STRING:
extension->repeated_string_value = extension->repeated_string_value =
Arena::CreateMessage<RepeatedPtrField<std::string>>(arena_); Arena::Create<RepeatedPtrField<std::string>>(arena_);
break; break;
case WireFormatLite::CPPTYPE_MESSAGE: case WireFormatLite::CPPTYPE_MESSAGE:
extension->repeated_message_value = extension->repeated_message_value =
Arena::CreateMessage<RepeatedPtrField<MessageLite>>(arena_); Arena::Create<RepeatedPtrField<MessageLite>>(arena_);
break; 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); ABSL_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_ENUM);
extension->is_repeated = true; extension->is_repeated = true;
extension->is_packed = packed; extension->is_packed = packed;
extension->repeated_enum_value = extension->repeated_enum_value = Arena::Create<RepeatedField<int>>(arena_);
Arena::CreateMessage<RepeatedField<int>>(arena_);
} else { } else {
ABSL_DCHECK_TYPE(*extension, REPEATED_FIELD, ENUM); ABSL_DCHECK_TYPE(*extension, REPEATED_FIELD, ENUM);
ABSL_DCHECK_EQ(extension->is_packed, packed); 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_repeated = true;
extension->is_packed = false; extension->is_packed = false;
extension->repeated_string_value = extension->repeated_string_value =
Arena::CreateMessage<RepeatedPtrField<std::string>>(arena_); Arena::Create<RepeatedPtrField<std::string>>(arena_);
} else { } else {
ABSL_DCHECK_TYPE(*extension, REPEATED_FIELD, STRING); 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); ABSL_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_MESSAGE);
extension->is_repeated = true; extension->is_repeated = true;
extension->repeated_message_value = extension->repeated_message_value =
Arena::CreateMessage<RepeatedPtrField<MessageLite>>(arena_); Arena::Create<RepeatedPtrField<MessageLite>>(arena_);
} else { } else {
ABSL_DCHECK_TYPE(*extension, REPEATED_FIELD, MESSAGE); ABSL_DCHECK_TYPE(*extension, REPEATED_FIELD, MESSAGE);
} }
@ -974,7 +973,7 @@ void ExtensionSet::InternalExtensionMergeFrom(const MessageLite* extendee,
case WireFormatLite::CPPTYPE_##UPPERCASE: \ case WireFormatLite::CPPTYPE_##UPPERCASE: \
if (is_new) { \ if (is_new) { \
extension->repeated_##LOWERCASE##_value = \ extension->repeated_##LOWERCASE##_value = \
Arena::CreateMessage<REPEATED_TYPE>(arena_); \ Arena::Create<REPEATED_TYPE>(arena_); \
} \ } \
extension->repeated_##LOWERCASE##_value->MergeFrom( \ extension->repeated_##LOWERCASE##_value->MergeFrom( \
*other_extension.repeated_##LOWERCASE##_value); \ *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); ABSL_DCHECK_EQ(cpp_type(extension->type), FieldDescriptor::CPPTYPE_MESSAGE);
extension->is_repeated = true; extension->is_repeated = true;
extension->repeated_message_value = extension->repeated_message_value =
Arena::CreateMessage<RepeatedPtrField<MessageLite> >(arena_); Arena::Create<RepeatedPtrField<MessageLite> >(arena_);
} else { } else {
ABSL_DCHECK_TYPE(*extension, REPEATED, MESSAGE); 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) { TEST(ExtensionSetTest, ArenaUnsafeArenaSetAllocatedAndRelease) {
Arena arena; Arena arena;
unittest::TestAllExtensions* message = unittest::TestAllExtensions* message =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena); Arena::Create<unittest::TestAllExtensions>(&arena);
unittest::ForeignMessage extension; unittest::ForeignMessage extension;
message->UnsafeArenaSetAllocatedExtension( message->UnsafeArenaSetAllocatedExtension(
unittest::optional_foreign_message_extension, &extension); unittest::optional_foreign_message_extension, &extension);
@ -232,7 +232,7 @@ TEST(ExtensionSetTest, UnsafeArenaSetAllocatedAndRelease) {
TEST(ExtensionSetTest, ArenaUnsafeArenaReleaseOfHeapAlloc) { TEST(ExtensionSetTest, ArenaUnsafeArenaReleaseOfHeapAlloc) {
Arena arena; Arena arena;
unittest::TestAllExtensions* message = unittest::TestAllExtensions* message =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena); Arena::Create<unittest::TestAllExtensions>(&arena);
unittest::ForeignMessage* extension = new unittest::ForeignMessage; unittest::ForeignMessage* extension = new unittest::ForeignMessage;
message->SetAllocatedExtension(unittest::optional_foreign_message_extension, message->SetAllocatedExtension(unittest::optional_foreign_message_extension,
extension); extension);
@ -363,7 +363,7 @@ TEST(ExtensionSetTest, SwapExtensionBothFull) {
TEST(ExtensionSetTest, ArenaSetAllExtension) { TEST(ExtensionSetTest, ArenaSetAllExtension) {
Arena arena1; Arena arena1;
unittest::TestAllExtensions* message1 = unittest::TestAllExtensions* message1 =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena1); Arena::Create<unittest::TestAllExtensions>(&arena1);
TestUtil::SetAllExtensions(message1); TestUtil::SetAllExtensions(message1);
TestUtil::ExpectAllExtensionsSet(*message1); TestUtil::ExpectAllExtensionsSet(*message1);
} }
@ -371,7 +371,7 @@ TEST(ExtensionSetTest, ArenaSetAllExtension) {
TEST(ExtensionSetTest, ArenaCopyConstructor) { TEST(ExtensionSetTest, ArenaCopyConstructor) {
Arena arena1; Arena arena1;
unittest::TestAllExtensions* message1 = unittest::TestAllExtensions* message1 =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena1); Arena::Create<unittest::TestAllExtensions>(&arena1);
TestUtil::SetAllExtensions(message1); TestUtil::SetAllExtensions(message1);
unittest::TestAllExtensions message2(*message1); unittest::TestAllExtensions message2(*message1);
arena1.Reset(); arena1.Reset();
@ -381,7 +381,7 @@ TEST(ExtensionSetTest, ArenaCopyConstructor) {
TEST(ExtensionSetTest, ArenaMergeFrom) { TEST(ExtensionSetTest, ArenaMergeFrom) {
Arena arena1; Arena arena1;
unittest::TestAllExtensions* message1 = unittest::TestAllExtensions* message1 =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena1); Arena::Create<unittest::TestAllExtensions>(&arena1);
TestUtil::SetAllExtensions(message1); TestUtil::SetAllExtensions(message1);
unittest::TestAllExtensions message2; unittest::TestAllExtensions message2;
message2.MergeFrom(*message1); message2.MergeFrom(*message1);
@ -392,8 +392,8 @@ TEST(ExtensionSetTest, ArenaMergeFrom) {
TEST(ExtensionSetTest, ArenaMergeFromWithClearedExtensions) { TEST(ExtensionSetTest, ArenaMergeFromWithClearedExtensions) {
Arena arena; Arena arena;
{ {
auto* message1 = Arena::CreateMessage<unittest::TestAllExtensions>(&arena); auto* message1 = Arena::Create<unittest::TestAllExtensions>(&arena);
auto* message2 = Arena::CreateMessage<unittest::TestAllExtensions>(&arena); auto* message2 = Arena::Create<unittest::TestAllExtensions>(&arena);
// Set an extension and then clear it // Set an extension and then clear it
message1->SetExtension(unittest::optional_int32_extension, 1); 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 // As more complicated case, let's have message1 and message2 share some
// uncleared extensions in common. // uncleared extensions in common.
auto* message1 = Arena::CreateMessage<unittest::TestAllExtensions>(&arena); auto* message1 = Arena::Create<unittest::TestAllExtensions>(&arena);
auto* message2 = Arena::CreateMessage<unittest::TestAllExtensions>(&arena); auto* message2 = Arena::Create<unittest::TestAllExtensions>(&arena);
// Set int32 and uint32 on both messages. // Set int32 and uint32 on both messages.
message1->SetExtension(unittest::optional_int32_extension, 1); message1->SetExtension(unittest::optional_int32_extension, 1);
@ -432,7 +432,7 @@ TEST(ExtensionSetTest, ArenaMergeFromWithClearedExtensions) {
TEST(ExtensionSetTest, ArenaSetAllocatedMessageAndRelease) { TEST(ExtensionSetTest, ArenaSetAllocatedMessageAndRelease) {
Arena arena; Arena arena;
unittest::TestAllExtensions* message = unittest::TestAllExtensions* message =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena); Arena::Create<unittest::TestAllExtensions>(&arena);
EXPECT_FALSE( EXPECT_FALSE(
message->HasExtension(unittest::optional_foreign_message_extension)); message->HasExtension(unittest::optional_foreign_message_extension));
// Add a extension using SetAllocatedExtension // Add a extension using SetAllocatedExtension
@ -456,9 +456,9 @@ TEST(ExtensionSetTest, SwapExtensionBothFullWithArena) {
std::unique_ptr<Arena> arena2(new Arena()); std::unique_ptr<Arena> arena2(new Arena());
unittest::TestAllExtensions* message1 = unittest::TestAllExtensions* message1 =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena1); Arena::Create<unittest::TestAllExtensions>(&arena1);
unittest::TestAllExtensions* message2 = unittest::TestAllExtensions* message2 =
Arena::CreateMessage<unittest::TestAllExtensions>(arena2.get()); Arena::Create<unittest::TestAllExtensions>(arena2.get());
TestUtil::SetAllExtensions(message1); TestUtil::SetAllExtensions(message1);
TestUtil::SetAllExtensions(message2); TestUtil::SetAllExtensions(message2);
@ -478,9 +478,9 @@ TEST(ExtensionSetTest, SwapExtensionBothFullWithArena) {
Arena arena3, arena4; Arena arena3, arena4;
unittest::TestAllExtensions* message3 = unittest::TestAllExtensions* message3 =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena3); Arena::Create<unittest::TestAllExtensions>(&arena3);
unittest::TestAllExtensions* message4 = unittest::TestAllExtensions* message4 =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena4); Arena::Create<unittest::TestAllExtensions>(&arena4);
TestUtil::SetAllExtensions(message3); TestUtil::SetAllExtensions(message3);
message3->Swap(message4); message3->Swap(message4);
arena3.Reset(); arena3.Reset();
@ -492,9 +492,9 @@ TEST(ExtensionSetTest, SwapFieldsOfExtensionBothFullWithArena) {
Arena* arena2 = new Arena(); Arena* arena2 = new Arena();
unittest::TestAllExtensions* message1 = unittest::TestAllExtensions* message1 =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena1); Arena::Create<unittest::TestAllExtensions>(&arena1);
unittest::TestAllExtensions* message2 = unittest::TestAllExtensions* message2 =
Arena::CreateMessage<unittest::TestAllExtensions>(arena2); Arena::Create<unittest::TestAllExtensions>(arena2);
TestUtil::SetAllExtensions(message1); TestUtil::SetAllExtensions(message1);
TestUtil::SetAllExtensions(message2); TestUtil::SetAllExtensions(message2);
@ -826,7 +826,7 @@ TEST(ExtensionSetTest, SpaceUsedExcludingSelf) {
#define TEST_REPEATED_EXTENSIONS_SPACE_USED(type, cpptype, value) \ #define TEST_REPEATED_EXTENSIONS_SPACE_USED(type, cpptype, value) \
do { \ do { \
std::unique_ptr<unittest::TestAllExtensions> message( \ std::unique_ptr<unittest::TestAllExtensions> message( \
Arena::CreateMessage<unittest::TestAllExtensions>(nullptr)); \ Arena::Create<unittest::TestAllExtensions>(nullptr)); \
const size_t base_size = message->SpaceUsedLong(); \ const size_t base_size = message->SpaceUsedLong(); \
size_t min_expected_size = sizeof(RepeatedField<cpptype>) + base_size; \ size_t min_expected_size = sizeof(RepeatedField<cpptype>) + base_size; \
message->AddExtension(unittest::repeated_##type##_extension, value); \ message->AddExtension(unittest::repeated_##type##_extension, value); \
@ -875,7 +875,7 @@ TEST(ExtensionSetTest, SpaceUsedExcludingSelf) {
// Repeated strings // Repeated strings
{ {
std::unique_ptr<unittest::TestAllExtensions> message( std::unique_ptr<unittest::TestAllExtensions> message(
Arena::CreateMessage<unittest::TestAllExtensions>(nullptr)); Arena::Create<unittest::TestAllExtensions>(nullptr));
const size_t base_size = message->SpaceUsedLong(); const size_t base_size = message->SpaceUsedLong();
size_t min_expected_size = size_t min_expected_size =
sizeof(RepeatedPtrField<std::string>) + base_size; sizeof(RepeatedPtrField<std::string>) + base_size;
@ -894,7 +894,7 @@ TEST(ExtensionSetTest, SpaceUsedExcludingSelf) {
// Repeated messages // Repeated messages
{ {
std::unique_ptr<unittest::TestAllExtensions> message( std::unique_ptr<unittest::TestAllExtensions> message(
Arena::CreateMessage<unittest::TestAllExtensions>(nullptr)); Arena::Create<unittest::TestAllExtensions>(nullptr));
const size_t base_size = message->SpaceUsedLong(); const size_t base_size = message->SpaceUsedLong();
size_t min_expected_size = size_t min_expected_size =
sizeof(RepeatedPtrField<unittest::ForeignMessage>) + base_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 || if (field->cpp_type() < FieldDescriptor::CPPTYPE_STRING ||
(field->cpp_type() == FieldDescriptor::CPPTYPE_STRING && (field->cpp_type() == FieldDescriptor::CPPTYPE_STRING &&
internal::cpp::EffectiveStringCType(field) == FieldOptions::CORD)) { internal::cpp::EffectiveStringCType(field) == FieldOptions::CORD)) {
ptr = reinterpret_cast<Type*>( ptr =
Arena::CreateMessage<RepeatedField<int32_t>>(arena)); reinterpret_cast<Type*>(Arena::Create<RepeatedField<int32_t>>(arena));
} else { } else {
ptr = reinterpret_cast<Type*>( ptr = reinterpret_cast<Type*>(Arena::Create<RepeatedPtrFieldBase>(arena));
Arena::CreateMessage<RepeatedPtrFieldBase>(arena));
} }
} }
return ptr; 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) { TEST_P(GeneratedMessageReflectionSwapTest, SwapFields) {
std::unique_ptr<unittest::TestAllTypes> lhs( std::unique_ptr<unittest::TestAllTypes> lhs(
Arena::CreateMessage<unittest::TestAllTypes>(nullptr)); Arena::Create<unittest::TestAllTypes>(nullptr));
std::unique_ptr<unittest::TestAllTypes> rhs( std::unique_ptr<unittest::TestAllTypes> rhs(
Arena::CreateMessage<unittest::TestAllTypes>(nullptr)); Arena::Create<unittest::TestAllTypes>(nullptr));
lhs->set_optional_double(12.3); lhs->set_optional_double(12.3);
lhs->mutable_repeated_int32()->Add(10); lhs->mutable_repeated_int32()->Add(10);
lhs->mutable_repeated_int32()->Add(20); lhs->mutable_repeated_int32()->Add(20);
@ -432,9 +432,9 @@ TEST_P(GeneratedMessageReflectionSwapTest, SwapFields) {
TEST_P(GeneratedMessageReflectionSwapTest, SwapFieldsAll) { TEST_P(GeneratedMessageReflectionSwapTest, SwapFieldsAll) {
std::unique_ptr<unittest::TestAllTypes> lhs( std::unique_ptr<unittest::TestAllTypes> lhs(
Arena::CreateMessage<unittest::TestAllTypes>(nullptr)); Arena::Create<unittest::TestAllTypes>(nullptr));
std::unique_ptr<unittest::TestAllTypes> rhs( std::unique_ptr<unittest::TestAllTypes> rhs(
Arena::CreateMessage<unittest::TestAllTypes>(nullptr)); Arena::Create<unittest::TestAllTypes>(nullptr));
TestUtil::SetAllFields(rhs.get()); TestUtil::SetAllFields(rhs.get());
@ -449,8 +449,8 @@ TEST_P(GeneratedMessageReflectionSwapTest, SwapFieldsAll) {
TEST(GeneratedMessageReflectionTest, SwapFieldsAllOnDifferentArena) { TEST(GeneratedMessageReflectionTest, SwapFieldsAllOnDifferentArena) {
Arena arena1, arena2; Arena arena1, arena2;
auto* message1 = Arena::CreateMessage<unittest::TestAllTypes>(&arena1); auto* message1 = Arena::Create<unittest::TestAllTypes>(&arena1);
auto* message2 = Arena::CreateMessage<unittest::TestAllTypes>(&arena2); auto* message2 = Arena::Create<unittest::TestAllTypes>(&arena2);
TestUtil::SetAllFields(message2); TestUtil::SetAllFields(message2);
@ -465,9 +465,9 @@ TEST(GeneratedMessageReflectionTest, SwapFieldsAllOnDifferentArena) {
TEST(GeneratedMessageReflectionTest, SwapFieldsAllOnArenaHeap) { TEST(GeneratedMessageReflectionTest, SwapFieldsAllOnArenaHeap) {
Arena arena; Arena arena;
auto* message1 = Arena::CreateMessage<unittest::TestAllTypes>(&arena); auto* message1 = Arena::Create<unittest::TestAllTypes>(&arena);
std::unique_ptr<unittest::TestAllTypes> message2( std::unique_ptr<unittest::TestAllTypes> message2(
Arena::CreateMessage<unittest::TestAllTypes>(nullptr)); Arena::Create<unittest::TestAllTypes>(nullptr));
TestUtil::SetAllFields(message2.get()); TestUtil::SetAllFields(message2.get());
@ -499,8 +499,8 @@ TEST(GeneratedMessageReflectionTest, SwapFieldsAllExtensionArenaHeap) {
Arena arena; Arena arena;
std::unique_ptr<unittest::TestAllExtensions> message1( std::unique_ptr<unittest::TestAllExtensions> message1(
Arena::CreateMessage<unittest::TestAllExtensions>(nullptr)); Arena::Create<unittest::TestAllExtensions>(nullptr));
auto* message2 = Arena::CreateMessage<unittest::TestAllExtensions>(&arena); auto* message2 = Arena::Create<unittest::TestAllExtensions>(&arena);
TestUtil::SetAllExtensions(message1.get()); TestUtil::SetAllExtensions(message1.get());
@ -515,8 +515,8 @@ TEST(GeneratedMessageReflectionTest, SwapFieldsAllExtensionArenaHeap) {
TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsAll) { TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsAll) {
Arena arena; Arena arena;
auto* message1 = Arena::CreateMessage<unittest::TestAllTypes>(&arena); auto* message1 = Arena::Create<unittest::TestAllTypes>(&arena);
auto* message2 = Arena::CreateMessage<unittest::TestAllTypes>(&arena); auto* message2 = Arena::Create<unittest::TestAllTypes>(&arena);
TestUtil::SetAllFields(message2); TestUtil::SetAllFields(message2);
@ -550,8 +550,8 @@ TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsAll) {
TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsMap) { TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsMap) {
Arena arena; Arena arena;
auto* message1 = Arena::CreateMessage<unittest::TestMap>(&arena); auto* message1 = Arena::Create<unittest::TestMap>(&arena);
auto* message2 = Arena::CreateMessage<unittest::TestMap>(&arena); auto* message2 = Arena::Create<unittest::TestMap>(&arena);
MapTestUtil::SetMapFields(message2); MapTestUtil::SetMapFields(message2);
@ -574,8 +574,8 @@ TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsMap) {
TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsAllExtension) { TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsAllExtension) {
Arena arena; Arena arena;
auto* message1 = Arena::CreateMessage<unittest::TestAllExtensions>(&arena); auto* message1 = Arena::Create<unittest::TestAllExtensions>(&arena);
auto* message2 = Arena::CreateMessage<unittest::TestAllExtensions>(&arena); auto* message2 = Arena::Create<unittest::TestAllExtensions>(&arena);
TestUtil::SetAllExtensions(message1); TestUtil::SetAllExtensions(message1);
@ -632,8 +632,8 @@ TEST(GeneratedMessageReflectionTest, SwapFieldsOneof) {
TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsOneof) { TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsOneof) {
Arena arena; Arena arena;
auto* message1 = Arena::CreateMessage<unittest::TestOneof2>(&arena); auto* message1 = Arena::Create<unittest::TestOneof2>(&arena);
auto* message2 = Arena::CreateMessage<unittest::TestOneof2>(&arena); auto* message2 = Arena::Create<unittest::TestOneof2>(&arena);
TestUtil::SetOneof1(message1); TestUtil::SetOneof1(message1);
std::vector<const FieldDescriptor*> fields; std::vector<const FieldDescriptor*> fields;
@ -651,8 +651,8 @@ TEST(GeneratedMessageReflectionTest, UnsafeShallowSwapFieldsOneof) {
TEST(GeneratedMessageReflectionTest, TEST(GeneratedMessageReflectionTest,
UnsafeShallowSwapFieldsOneofExpectShallow) { UnsafeShallowSwapFieldsOneofExpectShallow) {
Arena arena; Arena arena;
auto* message1 = Arena::CreateMessage<unittest::TestOneof2>(&arena); auto* message1 = Arena::Create<unittest::TestOneof2>(&arena);
auto* message2 = Arena::CreateMessage<unittest::TestOneof2>(&arena); auto* message2 = Arena::Create<unittest::TestOneof2>(&arena);
TestUtil::SetOneof1(message1); TestUtil::SetOneof1(message1);
message1->mutable_foo_message()->set_moo_int(1000); message1->mutable_foo_message()->set_moo_int(1000);
auto* kept_foo_ptr = message1->mutable_foo_message(); auto* kept_foo_ptr = message1->mutable_foo_message();
@ -887,7 +887,7 @@ TEST(GeneratedMessageReflectionTest, SetAllocatedMessageOnArenaTest) {
unittest::TestAllTypes from_message2; unittest::TestAllTypes from_message2;
Arena arena; Arena arena;
unittest::TestAllTypes* to_message = unittest::TestAllTypes* to_message =
Arena::CreateMessage<unittest::TestAllTypes>(&arena); Arena::Create<unittest::TestAllTypes>(&arena);
TestUtil::ReflectionTester reflection_tester( TestUtil::ReflectionTester reflection_tester(
unittest::TestAllTypes::descriptor()); unittest::TestAllTypes::descriptor());
reflection_tester.SetAllFieldsViaReflection(&from_message1); reflection_tester.SetAllFieldsViaReflection(&from_message1);
@ -953,7 +953,7 @@ TEST(GeneratedMessageReflectionTest, SetAllocatedExtensionMessageTest) {
TEST(GeneratedMessageReflectionTest, SetAllocatedExtensionMessageOnArenaTest) { TEST(GeneratedMessageReflectionTest, SetAllocatedExtensionMessageOnArenaTest) {
Arena arena; Arena arena;
unittest::TestAllExtensions* to_message = unittest::TestAllExtensions* to_message =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena); Arena::Create<unittest::TestAllExtensions>(&arena);
unittest::TestAllExtensions from_message1; unittest::TestAllExtensions from_message1;
unittest::TestAllExtensions from_message2; unittest::TestAllExtensions from_message2;
TestUtil::ReflectionTester reflection_tester( TestUtil::ReflectionTester reflection_tester(
@ -1185,7 +1185,7 @@ TEST(GeneratedMessageReflectionTest, SetAllocatedOneofMessageOnArenaTest) {
unittest::TestOneof2 from_message2; unittest::TestOneof2 from_message2;
Arena arena; Arena arena;
unittest::TestOneof2* to_message = unittest::TestOneof2* to_message =
Arena::CreateMessage<unittest::TestOneof2>(&arena); Arena::Create<unittest::TestOneof2>(&arena);
const Descriptor* descriptor = unittest::TestOneof2::descriptor(); const Descriptor* descriptor = unittest::TestOneof2::descriptor();
const Reflection* reflection = to_message->GetReflection(); const Reflection* reflection = to_message->GetReflection();
@ -1310,7 +1310,7 @@ TEST(GeneratedMessageReflectionTest, ReleaseOneofMessageTest) {
TEST(GeneratedMessageReflectionTest, ArenaReleaseMessageTest) { TEST(GeneratedMessageReflectionTest, ArenaReleaseMessageTest) {
Arena arena; Arena arena;
unittest::TestAllTypes* message = unittest::TestAllTypes* message =
Arena::CreateMessage<unittest::TestAllTypes>(&arena); Arena::Create<unittest::TestAllTypes>(&arena);
TestUtil::ReflectionTester reflection_tester( TestUtil::ReflectionTester reflection_tester(
unittest::TestAllTypes::descriptor()); unittest::TestAllTypes::descriptor());
@ -1334,7 +1334,7 @@ TEST(GeneratedMessageReflectionTest, ArenaReleaseMessageTest) {
TEST(GeneratedMessageReflectionTest, ArenaReleaseExtensionMessageTest) { TEST(GeneratedMessageReflectionTest, ArenaReleaseExtensionMessageTest) {
Arena arena; Arena arena;
unittest::TestAllExtensions* message = unittest::TestAllExtensions* message =
Arena::CreateMessage<unittest::TestAllExtensions>(&arena); Arena::Create<unittest::TestAllExtensions>(&arena);
TestUtil::ReflectionTester reflection_tester( TestUtil::ReflectionTester reflection_tester(
unittest::TestAllExtensions::descriptor()); unittest::TestAllExtensions::descriptor());
@ -1357,8 +1357,7 @@ TEST(GeneratedMessageReflectionTest, ArenaReleaseExtensionMessageTest) {
TEST(GeneratedMessageReflectionTest, ArenaReleaseOneofMessageTest) { TEST(GeneratedMessageReflectionTest, ArenaReleaseOneofMessageTest) {
Arena arena; Arena arena;
unittest::TestOneof2* message = unittest::TestOneof2* message = Arena::Create<unittest::TestOneof2>(&arena);
Arena::CreateMessage<unittest::TestOneof2>(&arena);
TestUtil::ReflectionTester::SetOneofViaReflection(message); TestUtil::ReflectionTester::SetOneofViaReflection(message);
const Descriptor* descriptor = unittest::TestOneof2::descriptor(); 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); if (!is_split) return RefAt<T>(x, offset);
void*& ptr = RefAt<void*>(x, offset); void*& ptr = RefAt<void*>(x, offset);
if (ptr == DefaultRawPtr()) { if (ptr == DefaultRawPtr()) {
ptr = Arena::CreateMessage<T>(msg->GetArena()); ptr = Arena::Create<T>(msg->GetArena());
} }
return *static_cast<T*>(ptr); 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; const ClassData* GetClassData() const final;
MessageLite* New(Arena* arena) const override { MessageLite* New(Arena* arena) const override {
return Arena::CreateMessage<ImplicitWeakMessage>(arena); return Arena::Create<ImplicitWeakMessage>(arena);
} }
void Clear() override { data_->clear(); } 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; // internal::NoHeapChecker no_heap;
protobuf_unittest::TestArenaMapLite* from = protobuf_unittest::TestArenaMapLite* from =
Arena::CreateMessage<protobuf_unittest::TestArenaMapLite>(arena_.get()); Arena::Create<protobuf_unittest::TestArenaMapLite>(arena_.get());
MapLiteTestUtil::SetArenaMapFields(from); MapLiteTestUtil::SetArenaMapFields(from);
from->SerializeToString(&data); from->SerializeToString(&data);
protobuf_unittest::TestArenaMapLite* to = protobuf_unittest::TestArenaMapLite* to =
Arena::CreateMessage<protobuf_unittest::TestArenaMapLite>(arena_.get()); Arena::Create<protobuf_unittest::TestArenaMapLite>(arena_.get());
to->ParseFromString(data); to->ParseFromString(data);
MapLiteTestUtil::ExpectArenaMapFieldsSet(*to); MapLiteTestUtil::ExpectArenaMapFieldsSet(*to);
} }
@ -51,8 +51,7 @@ TEST_F(LiteArenaTest, MapNoHeapAllocation) {
TEST_F(LiteArenaTest, UnknownFieldMemLeak) { TEST_F(LiteArenaTest, UnknownFieldMemLeak) {
protobuf_unittest::ForeignMessageArenaLite* message = protobuf_unittest::ForeignMessageArenaLite* message =
Arena::CreateMessage<protobuf_unittest::ForeignMessageArenaLite>( Arena::Create<protobuf_unittest::ForeignMessageArenaLite>(arena_.get());
arena_.get());
std::string data = "\012\000"; std::string data = "\012\000";
int original_capacity = data.capacity(); int original_capacity = data.capacity();
while (data.capacity() <= original_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) { TYPED_TEST(LiteTest, MapCrash) {
// See b/113635730 // See b/113635730
Arena arena; 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 > // 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 // 10 bytes. This causes a parse fail and a subsequent delete. field 16
// (map<int32, MapEnumLite>) tag = 128+2 = \202 \1 // (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; using DestructorSkippable_ = void;
Message* New(Arena* arena) const final { Message* New(Arena* arena) const final {
return Arena::CreateMessage<Derived>(arena); return Arena::Create<Derived>(arena);
} }
protected: 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 // Used in the implementation of parsing. Caller should take the ownership iff
// arena_ is nullptr. // arena_ is nullptr.
EntryType* NewEntry() const { EntryType* NewEntry() const {
return Arena::CreateMessage<EntryType>(this->arena()); return Arena::Create<EntryType>(this->arena());
} }
private: 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. // repeated fields are allocated from arenas.
// NoHeapChecker no_heap; // NoHeapChecker no_heap;
MapFieldType* map_field = Arena::CreateMessage<MapFieldType>(&arena); MapFieldType* map_field = Arena::Create<MapFieldType>(&arena);
// Set content in map // Set content in map
(*map_field->MutableMap())[100] = 101; (*map_field->MutableMap())[100] = 101;
@ -149,7 +149,7 @@ TEST_P(MapFieldBasePrimitiveTest, Arena) {
// repeated fields are allocated from arenas. // repeated fields are allocated from arenas.
// NoHeapChecker no_heap; // NoHeapChecker no_heap;
TestMapField* map_field = Arena::CreateMessage<TestMapField>(&arena); TestMapField* map_field = Arena::Create<TestMapField>(&arena);
// Trigger conversion to repeated field. // Trigger conversion to repeated field.
EXPECT_TRUE(map_field->MutableRepeatedField() != nullptr); EXPECT_TRUE(map_field->MutableRepeatedField() != nullptr);
@ -160,8 +160,7 @@ TEST_P(MapFieldBasePrimitiveTest, Arena) {
} }
TEST_P(MapFieldBasePrimitiveTest, EnforceNoArena) { TEST_P(MapFieldBasePrimitiveTest, EnforceNoArena) {
std::unique_ptr<TestMapField> map_field( std::unique_ptr<TestMapField> map_field(Arena::Create<TestMapField>(nullptr));
Arena::CreateMessage<TestMapField>(nullptr));
EXPECT_EQ(MapFieldTestPeer::GetArena(map_field->GetRepeatedField()), 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 kNumFields = 100;
static constexpr int kNumElems = 1000; static constexpr int kNumElems = 1000;
for (int i = 0; i < kNumFields; ++i) { 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(); auto& field = *values.back();
for (int j = 0; j < kNumElems; ++j) { for (int j = 0; j < kNumElems; ++j) {
field[j] = 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. // Use local_arena to allocate lhs to trigger use-after-free error.
Arena local_arena; Arena local_arena;
auto* lhs = Arena::CreateMessage<TestMap>(&local_arena); auto* lhs = Arena::Create<TestMap>(&local_arena);
const auto* reflection = lhs->GetReflection(); const auto* reflection = lhs->GetReflection();
std::vector<const FieldDescriptor*> fields; std::vector<const FieldDescriptor*> fields;
@ -4080,12 +4080,11 @@ TEST(ArenaTest, ParsingAndSerializingNoHeapAllocation) {
// NoHeapChecker no_heap; // NoHeapChecker no_heap;
UNITTEST::TestArenaMap* from = UNITTEST::TestArenaMap* from =
Arena::CreateMessage<UNITTEST::TestArenaMap>(&arena); Arena::Create<UNITTEST::TestArenaMap>(&arena);
MapTestUtil::SetArenaMapFields(from); MapTestUtil::SetArenaMapFields(from);
from->SerializeToString(&data); from->SerializeToString(&data);
UNITTEST::TestArenaMap* to = UNITTEST::TestArenaMap* to = Arena::Create<UNITTEST::TestArenaMap>(&arena);
Arena::CreateMessage<UNITTEST::TestArenaMap>(&arena);
to->ParseFromString(data); to->ParseFromString(data);
MapTestUtil::ExpectArenaMapFieldsSet(*to); MapTestUtil::ExpectArenaMapFieldsSet(*to);
} }
@ -4108,10 +4107,8 @@ TEST(ArenaTest, ReflectionInTextFormat) {
TextFormat::Printer printer; TextFormat::Printer printer;
TextFormat::Parser parser; TextFormat::Parser parser;
UNITTEST::TestArenaMap* from = UNITTEST::TestArenaMap* from = Arena::Create<UNITTEST::TestArenaMap>(&arena);
Arena::CreateMessage<UNITTEST::TestArenaMap>(&arena); UNITTEST::TestArenaMap* to = Arena::Create<UNITTEST::TestArenaMap>(&arena);
UNITTEST::TestArenaMap* to =
Arena::CreateMessage<UNITTEST::TestArenaMap>(&arena);
MapTestUtil::SetArenaMapFields(from); MapTestUtil::SetArenaMapFields(from);
printer.PrintToString(*from, &data); printer.PrintToString(*from, &data);
@ -4124,7 +4121,7 @@ TEST(ArenaTest, ReflectionInTextFormat) {
TEST(ArenaTest, StringMapNoLeak) { TEST(ArenaTest, StringMapNoLeak) {
Arena arena; Arena arena;
UNITTEST::TestArenaMap* message = UNITTEST::TestArenaMap* message =
Arena::CreateMessage<UNITTEST::TestArenaMap>(&arena); Arena::Create<UNITTEST::TestArenaMap>(&arena);
std::string data; std::string data;
// String with length less than 16 will not be allocated from heap. // String with length less than 16 will not be allocated from heap.
int original_capacity = data.capacity(); int original_capacity = data.capacity();
@ -4154,7 +4151,7 @@ TEST(ArenaTest, IsInitialized) {
Arena arena(options); Arena arena(options);
UNITTEST::TestArenaMap* message = UNITTEST::TestArenaMap* message =
Arena::CreateMessage<UNITTEST::TestArenaMap>(&arena); Arena::Create<UNITTEST::TestArenaMap>(&arena);
EXPECT_EQ(0, (*message->mutable_map_int32_int32())[0]); 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; Arena arena;
UNITTEST::NestedTestAllTypes* p1 = UNITTEST::NestedTestAllTypes* p1 =
Arena::CreateMessage<UNITTEST::NestedTestAllTypes>(&arena); Arena::Create<UNITTEST::NestedTestAllTypes>(&arena);
// Should parse correctly. // Should parse correctly.
EXPECT_TRUE(p1->ParseFromString(serialized)); EXPECT_TRUE(p1->ParseFromString(serialized));
UNITTEST::NestedTestAllTypes* p2 = UNITTEST::NestedTestAllTypes* p2 =
Arena::CreateMessage<UNITTEST::NestedTestAllTypes>(&arena); Arena::Create<UNITTEST::NestedTestAllTypes>(&arena);
p1->Swap(p2); p1->Swap(p2);
@ -1016,7 +1016,7 @@ TEST(MESSAGE_TEST_NAME, MessageIsStillValidAfterParseFails) {
{ {
Arena arena; Arena arena;
UNITTEST::TestAllTypes* arena_message = UNITTEST::TestAllTypes* arena_message =
Arena::CreateMessage<UNITTEST::TestAllTypes>(&arena); Arena::Create<UNITTEST::TestAllTypes>(&arena);
EXPECT_FALSE(arena_message->ParseFromString(invalid_string_data)); EXPECT_FALSE(arena_message->ParseFromString(invalid_string_data));
arena_message->Clear(); arena_message->Clear();
EXPECT_EQ("", arena_message->optional_string()); 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 // This call had a bug where the LazyField was not destroyed in any way
// causing the Cord inside it to leak its contents. // causing the Cord inside it to leak its contents.
EXPECT_TRUE( EXPECT_TRUE(
Arena::CreateMessage<UNITTEST::TestAllTypes>(&arena)->ParseFromString( Arena::Create<UNITTEST::TestAllTypes>(&arena)->ParseFromString(str));
str));
} }
} // namespace protobuf } // 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(); encoded = proto.SerializeAsString();
} }
Arena arena; 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. // We don't alter donation here, so it works even if the idx are bad.
ASSERT_TRUE(proto->ParseFromString(encoded)); ASSERT_TRUE(proto->ParseFromString(encoded));
// Now we alter donation bits. str2's bit (#2) will be off, but its aux_idx // Now we alter donation bits. str2's bit (#2) will be off, but its aux_idx
// (#3) will point to a donated string. // (#3) will point to a donated string.
proto = Arena::CreateMessage<Proto>(&arena); proto = Arena::Create<Proto>(&arena);
proto->mutable_str1(); proto->mutable_str1();
proto->mutable_str2(); proto->mutable_str2();
proto->mutable_str3(); proto->mutable_str3();

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

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

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

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

Write Preview
Loading…
Cancel
Save