third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/util/internal/protostream_objectsource.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 67 matching lines @@
     const google::protobuf::Type& type, int number);
 
 // Returns true if the field is packable.
 bool IsPackable(const google::protobuf::Field& field);
 
 // Finds an enum value with the given number. NULL if none found.
 const google::protobuf::EnumValue* FindEnumValueByNumber(
     const google::protobuf::Enum& tech_enum, int number);
 
 // Utility function to format nanos.
-const string FormatNanos(uint32 nanos);
+const string FormatNanos(uint32 nanos, bool with_trailing_zeros);
 
 StatusOr<string> MapKeyDefaultValueAsString(
     const google::protobuf::Field& field) {
   switch (field.kind()) {
     case google::protobuf::Field_Kind_TYPE_BOOL:
       return string("false");
     case google::protobuf::Field_Kind_TYPE_INT32:
     case google::protobuf::Field_Kind_TYPE_INT64:
     case google::protobuf::Field_Kind_TYPE_UINT32:
     case google::protobuf::Field_Kind_TYPE_UINT64:
@@ skipping 15 matching lines @@
 
 ProtoStreamObjectSource::ProtoStreamObjectSource(
     google::protobuf::io::CodedInputStream* stream, TypeResolver* type_resolver,
     const google::protobuf::Type& type)
     : stream_(stream),
       typeinfo_(TypeInfo::NewTypeInfo(type_resolver)),
       own_typeinfo_(true),
       type_(type),
       use_lower_camel_for_enums_(false),
       recursion_depth_(0),
-      max_recursion_depth_(kDefaultMaxRecursionDepth) {
+      max_recursion_depth_(kDefaultMaxRecursionDepth),
+      render_unknown_fields_(false),
+      add_trailing_zeros_for_timestamp_and_duration_(false) {
   GOOGLE_LOG_IF(DFATAL, stream == NULL) << "Input stream is NULL.";
 }
 
 ProtoStreamObjectSource::ProtoStreamObjectSource(
     google::protobuf::io::CodedInputStream* stream, const TypeInfo* typeinfo,
     const google::protobuf::Type& type)
     : stream_(stream),
       typeinfo_(typeinfo),
       own_typeinfo_(false),
       type_(type),
       use_lower_camel_for_enums_(false),
       recursion_depth_(0),
-      max_recursion_depth_(kDefaultMaxRecursionDepth) {
+      max_recursion_depth_(kDefaultMaxRecursionDepth),
+      render_unknown_fields_(false),
+      add_trailing_zeros_for_timestamp_and_duration_(false) {
   GOOGLE_LOG_IF(DFATAL, stream == NULL) << "Input stream is NULL.";
 }
 
 ProtoStreamObjectSource::~ProtoStreamObjectSource() {
   if (own_typeinfo_) {
     delete typeinfo_;
   }
 }
 
 Status ProtoStreamObjectSource::NamedWriteTo(StringPiece name,
@@ skipping 29 matching lines @@
 
     const TypeRenderer* type_renderer = FindTypeRenderer(type.name());
     if (type_renderer != NULL) {
       return (*type_renderer)(this, type, name, ow);
     }
 
   const google::protobuf::Field* field = NULL;
   string field_name;
   // last_tag set to dummy value that is different from tag.
   uint32 tag = stream_->ReadTag(), last_tag = tag + 1;
+  google::protobuf::UnknownFieldSet unknown_fields;
 
   if (include_start_and_end) {
     ow->StartObject(name);
   }
   while (tag != end_tag) {
     if (tag != last_tag) {  // Update field only if tag is changed.
       last_tag = tag;
       field = FindAndVerifyField(type, tag);
       if (field != NULL) {
         field_name = field->json_name();
       }
     }
     if (field == NULL) {
       // If we didn't find a field, skip this unknown tag.
       // TODO(wpoon): Check return boolean value.
-      WireFormat::SkipField(stream_, tag, NULL);
+      WireFormat::SkipField(stream_, tag,
+                            render_unknown_fields_ ? &unknown_fields : NULL);
       tag = stream_->ReadTag();
       continue;
     }
 
     if (field->cardinality() ==
         google::protobuf::Field_Cardinality_CARDINALITY_REPEATED) {
       bool check_maps = true;
 
       if (check_maps && IsMap(*field)) {
         ow->StartObject(field_name);
         ASSIGN_OR_RETURN(tag, RenderMap(field, field_name, tag, ow));
         ow->EndObject();
       } else {
         ASSIGN_OR_RETURN(tag, RenderList(field, field_name, tag, ow));
       }
     } else {
       // Render the field.
       RETURN_IF_ERROR(RenderField(field, field_name, ow));
       tag = stream_->ReadTag();
     }
   }
+
+
   if (include_start_and_end) {
     ow->EndObject();
   }
   return Status::OK;
 }
 
 StatusOr<uint32> ProtoStreamObjectSource::RenderList(
     const google::protobuf::Field* field, StringPiece name, uint32 list_tag,
     ObjectWriter* ow) const {
   uint32 tag_to_return = 0;
@@ skipping 41 matching lines @@
         if (map_key.empty()) {
           // An absent map key is treated as the default.
           const google::protobuf::Field* key_field =
               FindFieldByNumber(*field_type, 1);
           if (key_field == NULL) {
             // The Type info for this map entry is incorrect. It should always
             // have a field named "key" and with field number 1.
             return Status(util::error::INTERNAL, "Invalid map entry.");
           }
           ASSIGN_OR_RETURN(map_key, MapKeyDefaultValueAsString(*key_field));
+          // Key is empty, force it to render as empty (for string values).
+          ow->empty_name_ok_for_next_key();
         }
         RETURN_IF_ERROR(RenderField(field, map_key, ow));
       } else {
         // The Type info for this map entry is incorrect. It should contain
         // exactly two fields with field number 1 and 2.
         return Status(util::error::INTERNAL, "Invalid map entry.");
       }
     }
     stream_->PopLimit(old_limit);
   } while ((tag_to_return = stream_->ReadTag()) == list_tag);
   return tag_to_return;
 }
 
 Status ProtoStreamObjectSource::RenderPacked(
     const google::protobuf::Field* field, ObjectWriter* ow) const {
   uint32 length;
   stream_->ReadVarint32(&length);
   int old_limit = stream_->PushLimit(length);
   while (stream_->BytesUntilLimit() > 0) {
     RETURN_IF_ERROR(RenderField(field, StringPiece(), ow));
   }
   stream_->PopLimit(old_limit);
   return Status::OK;
 }
 
 Status ProtoStreamObjectSource::RenderTimestamp(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
-  pair<int64, int32> p = os->ReadSecondsAndNanos(type);
+  std::pair<int64, int32> p = os->ReadSecondsAndNanos(type);
   int64 seconds = p.first;
   int32 nanos = p.second;
   if (seconds > kTimestampMaxSeconds || seconds < kTimestampMinSeconds) {
     return Status(
         util::error::INTERNAL,
         StrCat("Timestamp seconds exceeds limit for field: ", field_name));
   }
 
   if (nanos < 0 || nanos >= kNanosPerSecond) {
     return Status(
         util::error::INTERNAL,
         StrCat("Timestamp nanos exceeds limit for field: ", field_name));
   }
 
   ow->RenderString(field_name,
                    ::google::protobuf::internal::FormatTime(seconds, nanos));
 
   return Status::OK;
 }
 
 Status ProtoStreamObjectSource::RenderDuration(
     const ProtoStreamObjectSource* os, const google::protobuf::Type& type,
     StringPiece field_name, ObjectWriter* ow) {
-  pair<int64, int32> p = os->ReadSecondsAndNanos(type);
+  std::pair<int64, int32> p = os->ReadSecondsAndNanos(type);
   int64 seconds = p.first;
   int32 nanos = p.second;
   if (seconds > kDurationMaxSeconds || seconds < kDurationMinSeconds) {
     return Status(
         util::error::INTERNAL,
         StrCat("Duration seconds exceeds limit for field: ", field_name));
   }
 
   if (nanos <= -kNanosPerSecond || nanos >= kNanosPerSecond) {
     return Status(
         util::error::INTERNAL,
         StrCat("Duration nanos exceeds limit for field: ", field_name));
   }
 
   string sign = "";
   if (seconds < 0) {
     if (nanos > 0) {
       return Status(util::error::INTERNAL,
                     StrCat("Duration nanos is non-negative, but seconds is "
                            "negative for field: ",
                            field_name));
     }
     sign = "-";
     seconds = -seconds;
     nanos = -nanos;
   } else if (seconds == 0 && nanos < 0) {
     sign = "-";
     nanos = -nanos;
   }
-  string formatted_duration = StringPrintf("%s%lld%ss", sign.c_str(), seconds,
-                                           FormatNanos(nanos).c_str());
+  string formatted_duration = StringPrintf(
+      "%s%lld%ss", sign.c_str(), seconds,
+      FormatNanos(nanos, os->add_trailing_zeros_for_timestamp_and_duration_)
+          .c_str());
   ow->RenderString(field_name, formatted_duration);
   return Status::OK;
 }
 
 Status ProtoStreamObjectSource::RenderDouble(const ProtoStreamObjectSource* os,
                                              const google::protobuf::Type& type,
                                              StringPiece field_name,
                                              ObjectWriter* ow) {
   uint32 tag = os->stream_->ReadTag();
   uint64 buffer64 = 0;  // default value of Double wrapper value
@@ skipping 465 matching lines @@
       if (field->type_url() == kStructNullValueTypeUrl) {
         ow->RenderNull(field_name);
         break;
       }
 
       // Get the nested enum type for this field.
       // TODO(skarvaje): Avoid string manipulation. Find ways to speed this
       // up.
       const google::protobuf::Enum* en =
           typeinfo_->GetEnumByTypeUrl(field->type_url());
-      // Lookup the name of the enum, and render that. Skips unknown enums.
+      // Lookup the name of the enum, and render that. Unknown enum values
+      // are printed as integers.
       if (en != NULL) {
         const google::protobuf::EnumValue* enum_value =
             FindEnumValueByNumber(*en, buffer32);
         if (enum_value != NULL) {
           if (use_lower_camel_for_enums_)
             ow->RenderString(field_name, ToCamelCase(enum_value->name()));
           else
             ow->RenderString(field_name, enum_value->name());
+        } else {
+          ow->RenderInt32(field_name, buffer32);
         }
       } else {
-        GOOGLE_LOG(INFO) << "Unknown enum skipped: " << field->type_url();
+        ow->RenderInt32(field_name, buffer32);
       }
       break;
     }
     case google::protobuf::Field_Kind_TYPE_STRING: {
       stream_->ReadVarint32(&buffer32);  // string size.
       stream_->ReadString(&strbuffer, buffer32);
       ow->RenderString(field_name, strbuffer);
       break;
     }
     case google::protobuf::Field_Kind_TYPE_BYTES: {
@@ skipping 130 matching lines @@
 // Field is a map if it is a repeated message and it has an option "map_type".
 // TODO(skarvaje): Consider pre-computing the IsMap() into Field directly.
 bool ProtoStreamObjectSource::IsMap(
     const google::protobuf::Field& field) const {
   const google::protobuf::Type* field_type =
       typeinfo_->GetTypeByTypeUrl(field.type_url());
 
   // TODO(xiaofeng): Unify option names.
   return field.kind() == google::protobuf::Field_Kind_TYPE_MESSAGE &&
          (GetBoolOptionOrDefault(field_type->options(),
-                                 "google.protobuf.MessageOptions.map_entry", false) ||
-          GetBoolOptionOrDefault(field_type->options(), "map_entry", false));
+                                 "google.protobuf.MessageOptions.map_entry",
+                                 false) ||
+          GetBoolOptionOrDefault(field_type->options(), "map_entry", false) ||
+          GetBoolOptionOrDefault(field_type->options(),
+                                 "proto2.MessageOptions.map_entry", false));
 }
 
 std::pair<int64, int32> ProtoStreamObjectSource::ReadSecondsAndNanos(
     const google::protobuf::Type& type) const {
   uint64 seconds = 0;
   uint32 nanos = 0;
   uint32 tag = 0;
   int64 signed_seconds = 0;
   int32 signed_nanos = 0;
 
@@ skipping 57 matching lines @@
     const google::protobuf::EnumValue& ev = tech_enum.enumvalue(i);
     if (ev.number() == number) {
       return &ev;
     }
   }
   return NULL;
 }
 
 // TODO(skarvaje): Look into optimizing this by not doing computation on
 // double.
-const string FormatNanos(uint32 nanos) {
+const string FormatNanos(uint32 nanos, bool with_trailing_zeros) {
+  if (nanos == 0) {
+    return with_trailing_zeros ? ".000" : "";
+  }
+
   const char* format =
       (nanos % 1000 != 0) ? "%.9f" : (nanos % 1000000 != 0) ? "%.6f" : "%.3f";
   string formatted =
       StringPrintf(format, static_cast<double>(nanos) / kNanosPerSecond);
   // remove the leading 0 before decimal.
   return formatted.substr(1);
 }
 }  // namespace
 
 }  // namespace converter
 }  // namespace util
 }  // namespace protobuf
 }  // namespace google
+