third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/util/internal/protostream_objectwriter.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 45 matching lines @@
 using util::StatusOr;
 
 
 ProtoStreamObjectWriter::ProtoStreamObjectWriter(
     TypeResolver* type_resolver, const google::protobuf::Type& type,
     strings::ByteSink* output, ErrorListener* listener,
     const ProtoStreamObjectWriter::Options& options)
     : ProtoWriter(type_resolver, type, output, listener),
       master_type_(type),
       current_(NULL),
-      options_(options) {}
+      options_(options) {
+  set_ignore_unknown_fields(options_.ignore_unknown_fields);
+  set_use_lower_camel_for_enums(options_.use_lower_camel_for_enums);
+}
 
 ProtoStreamObjectWriter::ProtoStreamObjectWriter(
     const TypeInfo* typeinfo, const google::protobuf::Type& type,
     strings::ByteSink* output, ErrorListener* listener)
     : ProtoWriter(typeinfo, type, output, listener),
       master_type_(type),
       current_(NULL),
       options_(ProtoStreamObjectWriter::Options::Defaults()) {}
 
 ProtoStreamObjectWriter::~ProtoStreamObjectWriter() {
@@ skipping 106 matching lines @@
       output_(&data_),
       depth_(0),
       is_well_known_type_(false),
       well_known_type_render_(NULL) {}
 
 ProtoStreamObjectWriter::AnyWriter::~AnyWriter() {}
 
 void ProtoStreamObjectWriter::AnyWriter::StartObject(StringPiece name) {
   ++depth_;
   // If an object writer is absent, that means we have not called StartAny()
-  // before reaching here. This is an invalid state. StartAny() gets called
-  // whenever we see an "@type" being rendered (see AnyWriter::RenderDataPiece).
+  // before reaching here, which happens when we have data before the "@type"
+  // field.
   if (ow_ == NULL) {
-    // Make sure we are not already in an invalid state. This avoids making
-    // multiple unnecessary InvalidValue calls.
-    if (!invalid_) {
-      parent_->InvalidValue("Any",
-                            StrCat("Missing or invalid @type for any field in ",
-                                   parent_->master_type_.name()));
-      invalid_ = true;
-    }
+    // Save data before the "@type" field for later replay.
+    uninterpreted_events_.push_back(Event(Event::START_OBJECT, name));
   } else if (is_well_known_type_ && depth_ == 1) {
     // For well-known types, the only other field besides "@type" should be a
     // "value" field.
     if (name != "value" && !invalid_) {
       parent_->InvalidValue("Any",
                             "Expect a \"value\" field for well-known types.");
       invalid_ = true;
     }
     ow_->StartObject("");
   } else {
     // Forward the call to the child writer if:
     //   1. the type is not a well-known type.
     //   2. or, we are in a nested Any, Struct, or Value object.
     ow_->StartObject(name);
   }
 }
 
 bool ProtoStreamObjectWriter::AnyWriter::EndObject() {
   --depth_;
-  // As long as depth_ >= 0, we know we haven't reached the end of Any.
-  // Propagate these EndObject() calls to the contained ow_. For regular
-  // message types, we propagate the end of Any as well.
-  if (ow_ != NULL && (depth_ >= 0 || !is_well_known_type_)) {
+  if (ow_ == NULL) {
+    if (depth_ >= 0) {
+      // Save data before the "@type" field for later replay.
+      uninterpreted_events_.push_back(Event(Event::END_OBJECT));
+    }
+  } else if (depth_ >= 0 || !is_well_known_type_) {
+    // As long as depth_ >= 0, we know we haven't reached the end of Any.
+    // Propagate these EndObject() calls to the contained ow_. For regular
+    // message types, we propagate the end of Any as well.
     ow_->EndObject();
   }
   // A negative depth_ implies that we have reached the end of Any
   // object. Now we write out its contents.
   if (depth_ < 0) {
     WriteAny();
     return false;
   }
   return true;
 }
 
 void ProtoStreamObjectWriter::AnyWriter::StartList(StringPiece name) {
   ++depth_;
-  // We expect ow_ to be present as this call only makes sense inside an Any.
   if (ow_ == NULL) {
-    if (!invalid_) {
-      parent_->InvalidValue("Any",
-                            StrCat("Missing or invalid @type for any field in ",
-                                   parent_->master_type_.name()));
-      invalid_ = true;
-    }
+    // Save data before the "@type" field for later replay.
+    uninterpreted_events_.push_back(Event(Event::START_LIST, name));
   } else if (is_well_known_type_ && depth_ == 1) {
     if (name != "value" && !invalid_) {
       parent_->InvalidValue("Any",
                             "Expect a \"value\" field for well-known types.");
       invalid_ = true;
     }
     ow_->StartList("");
   } else {
     ow_->StartList(name);
   }
 }
 
 void ProtoStreamObjectWriter::AnyWriter::EndList() {
   --depth_;
   if (depth_ < 0) {
     GOOGLE_LOG(DFATAL) << "Mismatched EndList found, should not be possible";
     depth_ = 0;
   }
-  // We don't write an error on the close, only on the open
-  if (ow_ != NULL) {
+  if (ow_ == NULL) {
+    // Save data before the "@type" field for later replay.
+    uninterpreted_events_.push_back(Event(Event::END_LIST));
+  } else {
     ow_->EndList();
   }
 }
 
 void ProtoStreamObjectWriter::AnyWriter::RenderDataPiece(
     StringPiece name, const DataPiece& value) {
   // Start an Any only at depth_ 0. Other RenderDataPiece calls with "@type"
   // should go to the contained ow_ as they indicate nested Anys.
   if (depth_ == 0 && ow_ == NULL && name == "@type") {
     StartAny(value);
   } else if (ow_ == NULL) {
-    if (!invalid_) {
-      parent_->InvalidValue("Any",
-                            StrCat("Missing or invalid @type for any field in ",
-                                   parent_->master_type_.name()));
-      invalid_ = true;
-    }
+    // Save data before the "@type" field.
+    uninterpreted_events_.push_back(Event(name, value));
   } else if (depth_ == 0 && is_well_known_type_) {
     if (name != "value" && !invalid_) {
       parent_->InvalidValue("Any",
                             "Expect a \"value\" field for well-known types.");
       invalid_ = true;
     }
     if (well_known_type_render_ == NULL) {
       // Only Any and Struct don't have a special type render but both of
       // them expect a JSON object (i.e., a StartObject() call).
-      if (!invalid_) {
+      if (value.type() != DataPiece::TYPE_NULL && !invalid_) {
         parent_->InvalidValue("Any", "Expect a JSON object.");
         invalid_ = true;
       }
     } else {
       ow_->ProtoWriter::StartObject("");
       Status status = (*well_known_type_render_)(ow_.get(), value);
       if (!status.ok()) ow_->InvalidValue("Any", status.error_message());
       ow_->ProtoWriter::EndObject();
     }
   } else {
@@ skipping 44 matching lines @@
   // example:
   // {
   //   "@type": "type.googleapis.com/google.protobuf.Value",
   //   "value": [1, 2, 3],
   // }
   // With the above JSON representation, we will only call StartList() on the
   // contained ow_.
   if (!is_well_known_type_) {
     ow_->StartObject("");
   }
+
+  // Now we know the proto type and can interpret all data fields we gathered
+  // before the "@type" field.
+  for (int i = 0; i < uninterpreted_events_.size(); ++i) {
+    uninterpreted_events_[i].Replay(this);
+  }
 }
 
 void ProtoStreamObjectWriter::AnyWriter::WriteAny() {
   if (ow_ == NULL) {
-    // If we had no object writer, we never got any content, so just return
-    // immediately, which is equivalent to writing an empty Any.
-    return;
+    if (uninterpreted_events_.empty()) {
+      // We never got any content, so just return immediately, which is
+      // equivalent to writing an empty Any.
+      return;
+    } else {
+      // There are uninterpreted data, but we never got a "@type" field.
+      if (!invalid_) {
+        parent_->InvalidValue("Any", StrCat("Missing @type for any field in ",
+                                            parent_->master_type_.name()));
+        invalid_ = true;
+      }
+      return;
+    }
   }
   // Render the type_url and value fields directly to the stream.
   // type_url has tag 1 and value has tag 2.
   WireFormatLite::WriteString(1, type_url_, parent_->stream());
   if (!data_.empty()) {
     WireFormatLite::WriteBytes(2, data_, parent_->stream());
   }
 }
 
+void ProtoStreamObjectWriter::AnyWriter::Event::Replay(
+    AnyWriter* writer) const {
+  switch (type_) {
+    case START_OBJECT:
+      writer->StartObject(name_);
+      break;
+    case END_OBJECT:
+      writer->EndObject();
+      break;
+    case START_LIST:
+      writer->StartList(name_);
+      break;
+    case END_LIST:
+      writer->EndList();
+      break;
+    case RENDER_DATA_PIECE:
+      writer->RenderDataPiece(name_, value_);
+      break;
+  }
+}
+
+void ProtoStreamObjectWriter::AnyWriter::Event::DeepCopy() {
+  // DataPiece only contains a string reference. To make sure the referenced
+  // string value stays valid, we make a copy of the string value and update
+  // DataPiece to reference our own copy.
+  if (value_.type() == DataPiece::TYPE_STRING) {
+    value_.str().AppendToString(&value_storage_);
+    value_ = DataPiece(value_storage_, value_.use_strict_base64_decoding());
+  } else if (value_.type() == DataPiece::TYPE_BYTES) {
+    value_storage_ = value_.ToBytes().ValueOrDie();
+    value_ =
+        DataPiece(value_storage_, true, value_.use_strict_base64_decoding());
+  }
+}
+
 ProtoStreamObjectWriter::Item::Item(ProtoStreamObjectWriter* enclosing,
                                     ItemType item_type, bool is_placeholder,
                                     bool is_list)
     : BaseElement(NULL),
       ow_(enclosing),
       any_(),
       item_type_(item_type),
       is_placeholder_(is_placeholder),
       is_list_(is_list) {
   if (item_type_ == ANY) {
     any_.reset(new AnyWriter(ow_));
   }
+  if (item_type == MAP) {
+    map_keys_.reset(new hash_set<string>);
+  }
 }
 
 ProtoStreamObjectWriter::Item::Item(ProtoStreamObjectWriter::Item* parent,
                                     ItemType item_type, bool is_placeholder,
                                     bool is_list)
     : BaseElement(parent),
       ow_(this->parent()->ow_),
       any_(),
       item_type_(item_type),
       is_placeholder_(is_placeholder),
       is_list_(is_list) {
   if (item_type == ANY) {
     any_.reset(new AnyWriter(ow_));
   }
+  if (item_type == MAP) {
+    map_keys_.reset(new hash_set<string>);
+  }
 }
 
 bool ProtoStreamObjectWriter::Item::InsertMapKeyIfNotPresent(
     StringPiece map_key) {
-  return InsertIfNotPresent(&map_keys_, map_key.ToString());
+  return InsertIfNotPresent(map_keys_.get(), map_key.ToString());
 }
 
 ProtoStreamObjectWriter* ProtoStreamObjectWriter::StartObject(
     StringPiece name) {
   if (invalid_depth() > 0) {
     IncrementInvalidDepth();
     return this;
   }
 
   // Starting the root message. Create the root Item and return.
@@ skipping 436 matching lines @@
                     "Invalid struct data type. Only number, string, boolean or "
                     "null values are supported.");
     }
   }
   ow->ProtoWriter::RenderDataPiece(struct_field_name, data);
   return Status::OK;
 }
 
 Status ProtoStreamObjectWriter::RenderTimestamp(ProtoStreamObjectWriter* ow,
                                                 const DataPiece& data) {
+  if (data.type() == DataPiece::TYPE_NULL) return Status::OK;
   if (data.type() != DataPiece::TYPE_STRING) {
     return Status(INVALID_ARGUMENT,
                   StrCat("Invalid data type for timestamp, value is ",
                          data.ValueAsStringOrDefault("")));
   }
 
   StringPiece value(data.str());
 
   int64 seconds;
   int32 nanos;
@@ skipping 10 matching lines @@
 
 static inline util::Status RenderOneFieldPath(ProtoStreamObjectWriter* ow,
                                                 StringPiece path) {
   ow->ProtoWriter::RenderDataPiece(
       "paths", DataPiece(ConvertFieldMaskPath(path, &ToSnakeCase), true));
   return Status::OK;
 }
 
 Status ProtoStreamObjectWriter::RenderFieldMask(ProtoStreamObjectWriter* ow,
                                                 const DataPiece& data) {
+  if (data.type() == DataPiece::TYPE_NULL) return Status::OK;
   if (data.type() != DataPiece::TYPE_STRING) {
     return Status(INVALID_ARGUMENT,
                   StrCat("Invalid data type for field mask, value is ",
                          data.ValueAsStringOrDefault("")));
   }
 
 // TODO(tsun): figure out how to do proto descriptor based snake case
 // conversions as much as possible. Because ToSnakeCase sometimes returns the
 // wrong value.
   google::protobuf::scoped_ptr<ResultCallback1<util::Status, StringPiece> > callback(
-      ::google::protobuf::internal::NewPermanentCallback(&RenderOneFieldPath, ow));
+      NewPermanentCallback(&RenderOneFieldPath, ow));
   return DecodeCompactFieldMaskPaths(data.str(), callback.get());
 }
 
 Status ProtoStreamObjectWriter::RenderDuration(ProtoStreamObjectWriter* ow,
                                                const DataPiece& data) {
+  if (data.type() == DataPiece::TYPE_NULL) return Status::OK;
   if (data.type() != DataPiece::TYPE_STRING) {
     return Status(INVALID_ARGUMENT,
                   StrCat("Invalid data type for duration, value is ",
                          data.ValueAsStringOrDefault("")));
   }
 
   StringPiece value(data.str());
 
   if (!value.ends_with("s")) {
     return Status(INVALID_ARGUMENT,
@@ skipping 29 matching lines @@
     return Status(INVALID_ARGUMENT, "Duration value exceeds limits");
   }
 
   ow->ProtoWriter::RenderDataPiece("seconds", DataPiece(seconds));
   ow->ProtoWriter::RenderDataPiece("nanos", DataPiece(nanos));
   return Status::OK;
 }
 
 Status ProtoStreamObjectWriter::RenderWrapperType(ProtoStreamObjectWriter* ow,
                                                   const DataPiece& data) {
+  if (data.type() == DataPiece::TYPE_NULL) return Status::OK;
   ow->ProtoWriter::RenderDataPiece("value", data);
   return Status::OK;
 }
 
 ProtoStreamObjectWriter* ProtoStreamObjectWriter::RenderDataPiece(
     StringPiece name, const DataPiece& data) {
   Status status;
   if (invalid_depth() > 0) return this;
 
   if (current_ == NULL) {
@@ skipping 26 matching lines @@
   if (current_->IsMap()) {
     if (!ValidMapKey(name)) return this;
 
     // Render an item in repeated map list.
     // { "key": "<name>", "value":
     Push("", Item::MESSAGE, false, false);
     ProtoWriter::RenderDataPiece("key",
                                  DataPiece(name, use_strict_base64_decoding()));
     field = Lookup("value");
     if (field == NULL) {
+      Pop();
       GOOGLE_LOG(DFATAL) << "Map does not have a value field.";
       return this;
     }
 
     const TypeRenderer* type_renderer = FindTypeRenderer(field->type_url());
     if (type_renderer != NULL) {
       // Map's value type is a special type. Render it like a message:
       // "value": {
       //   ... Render special type ...
       // }
@@ skipping 20 matching lines @@
     Pop();
     return this;
   }
 
   field = Lookup(name);
   if (field == NULL) return this;
 
   // Check if the field is of special type. Render it accordingly if so.
   const TypeRenderer* type_renderer = FindTypeRenderer(field->type_url());
   if (type_renderer != NULL) {
-    Push(name, Item::MESSAGE, false, false);
-    status = (*type_renderer)(this, data);
-    if (!status.ok()) {
-      InvalidValue(field->type_url(),
-                   StrCat("Field '", name, "', ", status.error_message()));
+    // Pass through null value only for google.protobuf.Value. For other
+    // types we ignore null value just like for regular field types.
+    if (data.type() != DataPiece::TYPE_NULL ||
+        field->type_url() == kStructValueTypeUrl) {
+      Push(name, Item::MESSAGE, false, false);
+      status = (*type_renderer)(this, data);
+      if (!status.ok()) {
+        InvalidValue(field->type_url(),
+                     StrCat("Field '", name, "', ", status.error_message()));
+      }
+      Pop();
     }
-    Pop();
     return this;
   }
 
   // If we are rendering explicit null values and the backend proto field is
   // not of the google.protobuf.NullType type, we do nothing.
   if (data.type() == DataPiece::TYPE_NULL &&
       field->type_url() != kStructNullValueTypeUrl) {
     return this;
   }
 
@@ skipping 111 matching lines @@
       field.kind() != google::protobuf::Field_Kind_TYPE_MESSAGE ||
       field.cardinality() !=
           google::protobuf::Field_Cardinality_CARDINALITY_REPEATED) {
     return false;
   }
   const google::protobuf::Type* field_type =
       typeinfo()->GetTypeByTypeUrl(field.type_url());
 
   // TODO(xiaofeng): Unify option names.
   return 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);
 }
 
 bool ProtoStreamObjectWriter::IsAny(const google::protobuf::Field& field) {
   return GetTypeWithoutUrl(field.type_url()) == kAnyType;
 }
 
 bool ProtoStreamObjectWriter::IsStruct(const google::protobuf::Field& field) {
   return GetTypeWithoutUrl(field.type_url()) == kStructType;
 }
 
 bool ProtoStreamObjectWriter::IsStructValue(
     const google::protobuf::Field& field) {
   return GetTypeWithoutUrl(field.type_url()) == kStructValueType;
 }
 
 bool ProtoStreamObjectWriter::IsStructListValue(
     const google::protobuf::Field& field) {
   return GetTypeWithoutUrl(field.type_url()) == kStructListValueType;
 }
 
 }  // namespace converter
 }  // namespace util
 }  // namespace protobuf
 }  // namespace google
+