third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/wire_format.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 289 matching lines @@
 
       // End group.
       target = io::CodedOutputStream::WriteTagToArray(
           WireFormatLite::kMessageSetItemEndTag, target);
     }
   }
 
   return target;
 }
 
-int WireFormat::ComputeUnknownFieldsSize(
+size_t WireFormat::ComputeUnknownFieldsSize(
     const UnknownFieldSet& unknown_fields) {
-  int size = 0;
+  size_t size = 0;
   for (int i = 0; i < unknown_fields.field_count(); i++) {
     const UnknownField& field = unknown_fields.field(i);
 
     switch (field.type()) {
       case UnknownField::TYPE_VARINT:
         size += io::CodedOutputStream::VarintSize32(
             WireFormatLite::MakeTag(field.number(),
             WireFormatLite::WIRETYPE_VARINT));
         size += io::CodedOutputStream::VarintSize64(field.varint());
         break;
@@ skipping 25 matching lines @@
         size += io::CodedOutputStream::VarintSize32(
             WireFormatLite::MakeTag(field.number(),
             WireFormatLite::WIRETYPE_END_GROUP));
         break;
     }
   }
 
   return size;
 }
 
-int WireFormat::ComputeUnknownMessageSetItemsSize(
+size_t WireFormat::ComputeUnknownMessageSetItemsSize(
     const UnknownFieldSet& unknown_fields) {
-  int size = 0;
+  size_t size = 0;
   for (int i = 0; i < unknown_fields.field_count(); i++) {
     const UnknownField& field = unknown_fields.field(i);
 
     // The only unknown fields that are allowed to exist in a MessageSet are
     // messages, which are length-delimited.
     if (field.type() == UnknownField::TYPE_LENGTH_DELIMITED) {
       size += WireFormatLite::kMessageSetItemTagsSize;
       size += io::CodedOutputStream::VarintSize32(field.number());
 
       int field_size = field.GetLengthDelimitedSize();
@@ skipping 414 matching lines @@
 
 // ===================================================================
 
 void WireFormat::SerializeWithCachedSizes(
     const Message& message,
     int size, io::CodedOutputStream* output) {
   const Descriptor* descriptor = message.GetDescriptor();
   const Reflection* message_reflection = message.GetReflection();
   int expected_endpoint = output->ByteCount() + size;
 
-  vector<const FieldDescriptor*> fields;
+  std::vector<const FieldDescriptor*> fields;
   message_reflection->ListFields(message, &fields);
   for (int i = 0; i < fields.size(); i++) {
     SerializeFieldWithCachedSizes(fields[i], message, output);
   }
 
   if (descriptor->options().message_set_wire_format()) {
     SerializeUnknownMessageSetItems(
         message_reflection->GetUnknownFields(message), output);
   } else {
     SerializeUnknownFields(
@@ skipping 25 matching lines @@
   if (field->is_repeated()) {
     count = message_reflection->FieldSize(message, field);
   } else if (message_reflection->HasField(message, field)) {
     count = 1;
   }
 
   const bool is_packed = field->is_packed();
   if (is_packed && count > 0) {
     WireFormatLite::WriteTag(field->number(),
         WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
-    const int data_size = FieldDataOnlyByteSize(field, message);
+    const size_t data_size = FieldDataOnlyByteSize(field, message);
     output->WriteVarint32(data_size);
   }
 
   for (int j = 0; j < count; j++) {
     switch (field->type()) {
 #define HANDLE_PRIMITIVE_TYPE(TYPE, CPPTYPE, TYPE_METHOD, CPPTYPE_METHOD)      \
       case FieldDescriptor::TYPE_##TYPE: {                                     \
         const CPPTYPE value = field->is_repeated() ?                           \
                               message_reflection->GetRepeated##CPPTYPE_METHOD( \
                                 message, field, j) :                           \
@@ skipping 105 matching lines @@
   const Message& sub_message = message_reflection->GetMessage(message, field);
   output->WriteVarint32(sub_message.GetCachedSize());
   sub_message.SerializeWithCachedSizes(output);
 
   // End group.
   output->WriteVarint32(WireFormatLite::kMessageSetItemEndTag);
 }
 
 // ===================================================================
 
-int WireFormat::ByteSize(const Message& message) {
+size_t WireFormat::ByteSize(const Message& message) {
   const Descriptor* descriptor = message.GetDescriptor();
   const Reflection* message_reflection = message.GetReflection();
 
-  int our_size = 0;
+  size_t our_size = 0;
 
-  vector<const FieldDescriptor*> fields;
+  std::vector<const FieldDescriptor*> fields;
   message_reflection->ListFields(message, &fields);
   for (int i = 0; i < fields.size(); i++) {
     our_size += FieldByteSize(fields[i], message);
   }
 
   if (descriptor->options().message_set_wire_format()) {
     our_size += ComputeUnknownMessageSetItemsSize(
       message_reflection->GetUnknownFields(message));
   } else {
     our_size += ComputeUnknownFieldsSize(
       message_reflection->GetUnknownFields(message));
   }
 
   return our_size;
 }
 
-int WireFormat::FieldByteSize(
+size_t WireFormat::FieldByteSize(
     const FieldDescriptor* field,
     const Message& message) {
   const Reflection* message_reflection = message.GetReflection();
 
   if (field->is_extension() &&
       field->containing_type()->options().message_set_wire_format() &&
       field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
       !field->is_repeated()) {
     return MessageSetItemByteSize(field, message);
   }
 
-  int count = 0;
+  size_t count = 0;
   if (field->is_repeated()) {
-    count = message_reflection->FieldSize(message, field);
+    count = FromIntSize(message_reflection->FieldSize(message, field));
   } else if (message_reflection->HasField(message, field)) {
     count = 1;
   }
 
-  const int data_size = FieldDataOnlyByteSize(field, message);
-  int our_size = data_size;
+  const size_t data_size = FieldDataOnlyByteSize(field, message);
+  size_t our_size = data_size;
   if (field->is_packed()) {
     if (data_size > 0) {
       // Packed fields get serialized like a string, not their native type.
       // Technically this doesn't really matter; the size only changes if it's
       // a GROUP
       our_size += TagSize(field->number(), FieldDescriptor::TYPE_STRING);
       our_size += io::CodedOutputStream::VarintSize32(data_size);
     }
   } else {
     our_size += count * TagSize(field->number(), field->type());
   }
   return our_size;
 }
 
-int WireFormat::FieldDataOnlyByteSize(
+size_t WireFormat::FieldDataOnlyByteSize(
     const FieldDescriptor* field,
     const Message& message) {
   const Reflection* message_reflection = message.GetReflection();
 
-  int count = 0;
+  size_t count = 0;
   if (field->is_repeated()) {
-    count = message_reflection->FieldSize(message, field);
+    count =
+        internal::FromIntSize(message_reflection->FieldSize(message, field));
   } else if (message_reflection->HasField(message, field)) {
     count = 1;
   }
 
-  int data_size = 0;
+  size_t data_size = 0;
   switch (field->type()) {
 #define HANDLE_TYPE(TYPE, TYPE_METHOD, CPPTYPE_METHOD)                     \
     case FieldDescriptor::TYPE_##TYPE:                                     \
       if (field->is_repeated()) {                                          \
         for (int j = 0; j < count; j++) {                                  \
           data_size += WireFormatLite::TYPE_METHOD##Size(                  \
             message_reflection->GetRepeated##CPPTYPE_METHOD(               \
               message, field, j));                                         \
         }                                                                  \
       } else {                                                             \
@@ skipping 53 matching lines @@
             message, field, j, &scratch) :
           message_reflection->GetStringReference(message, field, &scratch);
         data_size += WireFormatLite::StringSize(value);
       }
       break;
     }
   }
   return data_size;
 }
 
-int WireFormat::MessageSetItemByteSize(
+size_t WireFormat::MessageSetItemByteSize(
     const FieldDescriptor* field,
     const Message& message) {
   const Reflection* message_reflection = message.GetReflection();
 
-  int our_size = WireFormatLite::kMessageSetItemTagsSize;
+  size_t our_size = WireFormatLite::kMessageSetItemTagsSize;
 
   // type_id
   our_size += io::CodedOutputStream::VarintSize32(field->number());
 
   // message
   const Message& sub_message = message_reflection->GetMessage(message, field);
-  int message_size = sub_message.ByteSize();
+  size_t message_size = sub_message.ByteSizeLong();
 
   our_size += io::CodedOutputStream::VarintSize32(message_size);
   our_size += message_size;
 
   return our_size;
 }
 
 }  // namespace internal
 }  // namespace protobuf
 }  // namespace google