Reverts third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/src/google/protobuf/dynamic_message.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 52 matching lines @@
 // I don't have the book on me right now so I'm not sure.
 
 #include <algorithm>
 #include <google/protobuf/stubs/hash.h>
 #include <memory>
 #ifndef _SHARED_PTR_H
 #include <google/protobuf/stubs/shared_ptr.h>
 #endif
 
 #include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/scoped_ptr.h>
 
 #include <google/protobuf/dynamic_message.h>
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/descriptor.pb.h>
 #include <google/protobuf/generated_message_util.h>
 #include <google/protobuf/generated_message_reflection.h>
 #include <google/protobuf/arenastring.h>
 #include <google/protobuf/map_field_inl.h>
 #include <google/protobuf/reflection_ops.h>
 #include <google/protobuf/repeated_field.h>
 #include <google/protobuf/map_type_handler.h>
 #include <google/protobuf/extension_set.h>
 #include <google/protobuf/wire_format.h>
 #include <google/protobuf/map_field.h>
 
 namespace google {
 namespace protobuf {
 
-using internal::DynamicMapField;
+using internal::WireFormat;
 using internal::ExtensionSet;
 using internal::GeneratedMessageReflection;
-using internal::InternalMetadataWithArena;
 using internal::MapField;
+using internal::DynamicMapField;
 
 
 using internal::ArenaStringPtr;
 
 // ===================================================================
 // Some helper tables and functions...
 
 namespace {
 
 bool IsMapFieldInApi(const FieldDescriptor* field) {
@@ skipping 108 matching lines @@
 }  // namespace
 
 // ===================================================================
 
 class DynamicMessage : public Message {
  public:
   struct TypeInfo {
     int size;
     int has_bits_offset;
     int oneof_case_offset;
-    int internal_metadata_offset;
+    int unknown_fields_offset;
     int extensions_offset;
+    int is_default_instance_offset;
 
     // Not owned by the TypeInfo.
     DynamicMessageFactory* factory;  // The factory that created this object.
     const DescriptorPool* pool;      // The factory's DescriptorPool.
     const Descriptor* type;          // Type of this DynamicMessage.
 
     // Warning:  The order in which the following pointers are defined is
     //   important (the prototype must be deleted *before* the offsets).
-    google::protobuf::scoped_array<uint32> offsets;
-    google::protobuf::scoped_array<uint32> has_bits_indices;
+    google::protobuf::scoped_array<int> offsets;
     google::protobuf::scoped_ptr<const GeneratedMessageReflection> reflection;
     // Don't use a scoped_ptr to hold the prototype: the destructor for
     // DynamicMessage needs to know whether it is the prototype, and does so by
     // looking back at this field. This would assume details about the
     // implementation of scoped_ptr.
     const DynamicMessage* prototype;
     void* default_oneof_instance;
 
     TypeInfo() : prototype(NULL), default_oneof_instance(NULL) {}
 
@@ skipping 75 matching lines @@
   // it now.  We use placement new even for primitive types that don't have
   // constructors for consistency.  (In theory, placement new should be used
   // any time you are trying to convert untyped memory to typed memory, though
   // in practice that's not strictly necessary for types that don't have a
   // constructor.)
 
   const Descriptor* descriptor = type_info_->type;
 
   // Initialize oneof cases.
   for (int i = 0 ; i < descriptor->oneof_decl_count(); ++i) {
-    new (OffsetToPointer(type_info_->oneof_case_offset + sizeof(uint32) * i))
+    new(OffsetToPointer(type_info_->oneof_case_offset + sizeof(uint32) * i))
         uint32(0);
   }
 
-  new (OffsetToPointer(type_info_->internal_metadata_offset))
-      InternalMetadataWithArena;
+  if (type_info_->is_default_instance_offset != -1) {
+    *reinterpret_cast<bool*>(
+        OffsetToPointer(type_info_->is_default_instance_offset)) = false;
+  }
+
+  new(OffsetToPointer(type_info_->unknown_fields_offset)) UnknownFieldSet;
 
   if (type_info_->extensions_offset != -1) {
-    new (OffsetToPointer(type_info_->extensions_offset)) ExtensionSet;
+    new(OffsetToPointer(type_info_->extensions_offset)) ExtensionSet;
   }
 
   for (int i = 0; i < descriptor->field_count(); i++) {
     const FieldDescriptor* field = descriptor->field(i);
     void* field_ptr = OffsetToPointer(type_info_->offsets[i]);
     if (field->containing_oneof()) {
       continue;
     }
     switch (field->cpp_type()) {
 #define HANDLE_TYPE(CPPTYPE, TYPE)                                           \
@@ skipping 24 matching lines @@
 
       case FieldDescriptor::CPPTYPE_STRING:
         switch (field->options().ctype()) {
           default:  // TODO(kenton):  Support other string reps.
           case FieldOptions::STRING:
             if (!field->is_repeated()) {
               const string* default_value;
               if (is_prototype()) {
                 default_value = &field->default_value_string();
               } else {
-                default_value = &(reinterpret_cast<const ArenaStringPtr*>(
-                                      type_info_->prototype->OffsetToPointer(
-                                          type_info_->offsets[i]))
-                                      ->Get());
+                default_value =
+                  &(reinterpret_cast<const ArenaStringPtr*>(
+                    type_info_->prototype->OffsetToPointer(
+                      type_info_->offsets[i]))->Get(NULL));
               }
               ArenaStringPtr* asp = new(field_ptr) ArenaStringPtr();
               asp->UnsafeSetDefault(default_value);
             } else {
               new(field_ptr) RepeatedPtrField<string>();
             }
             break;
         }
         break;
 
@@ skipping 10 matching lines @@
         }
         break;
       }
     }
   }
 }
 
 DynamicMessage::~DynamicMessage() {
   const Descriptor* descriptor = type_info_->type;
 
-  reinterpret_cast<InternalMetadataWithArena*>(
-      OffsetToPointer(type_info_->internal_metadata_offset))
-      ->~InternalMetadataWithArena();
+  reinterpret_cast<UnknownFieldSet*>(
+    OffsetToPointer(type_info_->unknown_fields_offset))->~UnknownFieldSet();
 
   if (type_info_->extensions_offset != -1) {
     reinterpret_cast<ExtensionSet*>(
       OffsetToPointer(type_info_->extensions_offset))->~ExtensionSet();
   }
 
   // We need to manually run the destructors for repeated fields and strings,
   // just as we ran their constructors in the DynamicMessage constructor.
   // We also need to manually delete oneof fields if it is set and is string
   // or message.
@@ skipping 10 matching lines @@
       if (*(reinterpret_cast<const uint32*>(field_ptr)) ==
           field->number()) {
         field_ptr = OffsetToPointer(type_info_->offsets[
             descriptor->field_count() + field->containing_oneof()->index()]);
         if (field->cpp_type() == FieldDescriptor::CPPTYPE_STRING) {
           switch (field->options().ctype()) {
             default:
             case FieldOptions::STRING: {
               const ::std::string* default_value =
                   &(reinterpret_cast<const ArenaStringPtr*>(
-                        reinterpret_cast<uint8*>(
-                            type_info_->default_oneof_instance) +
-                        type_info_->offsets[i])
-                        ->Get());
+                      reinterpret_cast<uint8*>(
+                          type_info_->default_oneof_instance)
+                      + type_info_->offsets[i])
+                    ->Get(NULL));
               reinterpret_cast<ArenaStringPtr*>(field_ptr)->Destroy(
                   default_value, NULL);
               break;
             }
           }
         } else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
             delete *reinterpret_cast<Message**>(field_ptr);
         }
       }
       continue;
@@ skipping 37 matching lines @@
           }
           break;
       }
 
     } else if (field->cpp_type() == FieldDescriptor::CPPTYPE_STRING) {
       switch (field->options().ctype()) {
         default:  // TODO(kenton):  Support other string reps.
         case FieldOptions::STRING: {
           const ::std::string* default_value =
               &(reinterpret_cast<const ArenaStringPtr*>(
-                    type_info_->prototype->OffsetToPointer(
-                        type_info_->offsets[i]))
-                    ->Get());
+                  type_info_->prototype->OffsetToPointer(
+                      type_info_->offsets[i]))->Get(NULL));
           reinterpret_cast<ArenaStringPtr*>(field_ptr)->Destroy(
               default_value, NULL);
           break;
         }
       }
     } else if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
       if (!is_prototype()) {
         Message* message = *reinterpret_cast<Message**>(field_ptr);
         if (message != NULL) {
           delete message;
@@ skipping 22 matching lines @@
     if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
         !field->is_repeated()) {
       // For fields with message types, we need to cross-link with the
       // prototype for the field's type.
       // For singular fields, the field is just a pointer which should
       // point to the prototype.
       *reinterpret_cast<const Message**>(field_ptr) =
         factory->GetPrototypeNoLock(field->message_type());
     }
   }
+
+  // Set as the default instance -- this affects field-presence semantics for
+  // proto3.
+  if (type_info_->is_default_instance_offset != -1) {
+    void* is_default_instance_ptr =
+        OffsetToPointer(type_info_->is_default_instance_offset);
+    *reinterpret_cast<bool*>(is_default_instance_ptr) = true;
+  }
 }
 
 Message* DynamicMessage::New() const {
   void* new_base = operator new(type_info_->size);
   memset(new_base, 0, type_info_->size);
   return new(new_base) DynamicMessage(type_info_);
 }
 
 Message* DynamicMessage::New(::google::protobuf::Arena* arena) const {
   if (arena != NULL) {
@@ skipping 79 matching lines @@
 
   // We need to construct all the structures passed to
   // GeneratedMessageReflection's constructor.  This includes:
   // - A block of memory that contains space for all the message's fields.
   // - An array of integers indicating the byte offset of each field within
   //   this block.
   // - A big bitfield containing a bit for each field indicating whether
   //   or not that field is set.
 
   // Compute size and offsets.
-  uint32* offsets =
-      new uint32[type->field_count() + type->oneof_decl_count()];
+  int* offsets = new int[type->field_count() + type->oneof_decl_count()];
   type_info->offsets.reset(offsets);
 
   // Decide all field offsets by packing in order.
   // We place the DynamicMessage object itself at the beginning of the allocated
   // space.
   int size = sizeof(DynamicMessage);
   size = AlignOffset(size);
 
   // Next the has_bits, which is an array of uint32s.
   if (type->file()->syntax() == FileDescriptor::SYNTAX_PROTO3) {
     type_info->has_bits_offset = -1;
   } else {
     type_info->has_bits_offset = size;
     int has_bits_array_size =
       DivideRoundingUp(type->field_count(), bitsizeof(uint32));
     size += has_bits_array_size * sizeof(uint32);
     size = AlignOffset(size);
+  }
 
-    uint32* has_bits_indices = new uint32[type->field_count()];
-    for (int i = 0; i < type->field_count(); i++) {
-      has_bits_indices[i] = i;
-    }
-    type_info->has_bits_indices.reset(has_bits_indices);
+  // The is_default_instance member, if any.
+  if (type->file()->syntax() == FileDescriptor::SYNTAX_PROTO3) {
+    type_info->is_default_instance_offset = size;
+    size += sizeof(bool);
+    size = AlignOffset(size);
+  } else {
+    type_info->is_default_instance_offset = -1;
   }
 
   // The oneof_case, if any. It is an array of uint32s.
   if (type->oneof_decl_count() > 0) {
     type_info->oneof_case_offset = size;
     size += type->oneof_decl_count() * sizeof(uint32);
     size = AlignOffset(size);
   }
 
   // The ExtensionSet, if any.
   if (type->extension_range_count() > 0) {
     type_info->extensions_offset = size;
     size += sizeof(ExtensionSet);
     size = AlignOffset(size);
   } else {
     // No extensions.
     type_info->extensions_offset = -1;
   }
 
   // All the fields.
-  //
-  // TODO(b/31226269):  Optimize the order of fields to minimize padding.
   for (int i = 0; i < type->field_count(); i++) {
     // Make sure field is aligned to avoid bus errors.
     // Oneof fields do not use any space.
     if (!type->field(i)->containing_oneof()) {
       int field_size = FieldSpaceUsed(type->field(i));
       size = AlignTo(size, std::min(kSafeAlignment, field_size));
       offsets[i] = size;
       size += field_size;
     }
   }
 
   // The oneofs.
   for (int i = 0; i < type->oneof_decl_count(); i++) {
     size = AlignTo(size, kSafeAlignment);
     offsets[type->field_count() + i] = size;
     size += kMaxOneofUnionSize;
   }
 
-  // Add the InternalMetadataWithArena to the end.
+  // Add the UnknownFieldSet to the end.
   size = AlignOffset(size);
-  type_info->internal_metadata_offset = size;
-  size += sizeof(InternalMetadataWithArena);
+  type_info->unknown_fields_offset = size;
+  size += sizeof(UnknownFieldSet);
 
   // Align the final size to make sure no clever allocators think that
   // alignment is not necessary.
   size = AlignOffset(size);
   type_info->size = size;
 
   // Allocate the prototype.
   void* base = operator new(size);
   memset(base, 0, size);
   // The prototype in type_info has to be set before creating the prototype
   // instance on memory. e.g., message Foo { map<int32, Foo> a = 1; }. When
   // creating prototype for Foo, prototype of the map entry will also be
   // created, which needs the address of the prototype of Foo (the value in
   // map). To break the cyclic dependency, we have to assgin the address of
   // prototype into type_info first.
   type_info->prototype = static_cast<DynamicMessage*>(base);
   DynamicMessage* prototype = new(base) DynamicMessage(type_info);
 
   // Construct the reflection object.
-
-  void* default_oneof_instance = NULL;
-  int oneof_case_offset = -1;
-
   if (type->oneof_decl_count() > 0) {
     // Compute the size of default oneof instance and offsets of default
     // oneof fields.
     int oneof_size = 0;
     for (int i = 0; i < type->oneof_decl_count(); i++) {
       for (int j = 0; j < type->oneof_decl(i)->field_count(); j++) {
         const FieldDescriptor* field = type->oneof_decl(i)->field(j);
         int field_size = OneofFieldSpaceUsed(field);
         oneof_size = AlignTo(oneof_size, std::min(kSafeAlignment, field_size));
         offsets[field->index()] = oneof_size;
         oneof_size += field_size;
       }
     }
     // Construct default oneof instance.
     type_info->default_oneof_instance = ::operator new(oneof_size);
     ConstructDefaultOneofInstance(type_info->type,
                                   type_info->offsets.get(),
                                   type_info->default_oneof_instance);
-    default_oneof_instance = type_info->default_oneof_instance;
-    oneof_case_offset = type_info->oneof_case_offset;
+    type_info->reflection.reset(
+        new GeneratedMessageReflection(
+            type_info->type,
+            type_info->prototype,
+            type_info->offsets.get(),
+            type_info->has_bits_offset,
+            type_info->unknown_fields_offset,
+            type_info->extensions_offset,
+            type_info->default_oneof_instance,
+            type_info->oneof_case_offset,
+            type_info->pool,
+            this,
+            type_info->size,
+            -1 /* arena_offset */,
+            type_info->is_default_instance_offset));
+  } else {
+    type_info->reflection.reset(
+        new GeneratedMessageReflection(
+            type_info->type,
+            type_info->prototype,
+            type_info->offsets.get(),
+            type_info->has_bits_offset,
+            type_info->unknown_fields_offset,
+            type_info->extensions_offset,
+            type_info->pool,
+            this,
+            type_info->size,
+            -1 /* arena_offset */,
+            type_info->is_default_instance_offset));
   }
-
-  internal::ReflectionSchema schema = {
-      type_info->prototype,
-      type_info->offsets.get(),
-      type_info->has_bits_indices.get(),
-      type_info->has_bits_offset,
-      type_info->internal_metadata_offset,
-      type_info->extensions_offset,
-      default_oneof_instance,
-      oneof_case_offset,
-      type_info->size};
-
-  type_info->reflection.reset(new GeneratedMessageReflection(
-      type_info->type, schema, type_info->pool, this));
-
   // Cross link prototypes.
   prototype->CrossLinkPrototypes();
 
   return prototype;
 }
 
 void DynamicMessageFactory::ConstructDefaultOneofInstance(
     const Descriptor* type,
-    const uint32 offsets[],
+    const int offsets[],
     void* default_oneof_instance) {
   for (int i = 0; i < type->oneof_decl_count(); i++) {
     for (int j = 0; j < type->oneof_decl(i)->field_count(); j++) {
       const FieldDescriptor* field = type->oneof_decl(i)->field(j);
       void* field_ptr = reinterpret_cast<uint8*>(
           default_oneof_instance) + offsets[field->index()];
       switch (field->cpp_type()) {
 #define HANDLE_TYPE(CPPTYPE, TYPE)                                      \
         case FieldDescriptor::CPPTYPE_##CPPTYPE:                        \
           new(field_ptr) TYPE(field->default_value_##TYPE());           \
@@ skipping 25 matching lines @@
           new(field_ptr) Message*(NULL);
           break;
         }
       }
     }
   }
 }
 
 void DynamicMessageFactory::DeleteDefaultOneofInstance(
     const Descriptor* type,
-    const uint32 offsets[],
+    const int offsets[],
     void* default_oneof_instance) {
   for (int i = 0; i < type->oneof_decl_count(); i++) {
     for (int j = 0; j < type->oneof_decl(i)->field_count(); j++) {
       const FieldDescriptor* field = type->oneof_decl(i)->field(j);
       if (field->cpp_type() == FieldDescriptor::CPPTYPE_STRING) {
         switch (field->options().ctype()) {
           default:
           case FieldOptions::STRING:
             break;
         }
       }
     }
   }
 }
 
 }  // namespace protobuf
 }  // namespace google