third_party/protobuf: Update to HEAD (5f65ee6ac7)

third_party/protobuf/src/google/protobuf/util/internal/default_value_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 46 matching lines @@
 }  // namespace
 
 DefaultValueObjectWriter::DefaultValueObjectWriter(
     TypeResolver* type_resolver, const google::protobuf::Type& type,
     ObjectWriter* ow)
     : typeinfo_(TypeInfo::NewTypeInfo(type_resolver)),
       own_typeinfo_(true),
       type_(type),
       current_(NULL),
       root_(NULL),
+      suppress_empty_list_(false),
       field_scrub_callback_(NULL),
       ow_(ow) {}
 
 DefaultValueObjectWriter::~DefaultValueObjectWriter() {
   for (int i = 0; i < string_values_.size(); ++i) {
     delete string_values_[i];
   }
   if (own_typeinfo_) {
     delete typeinfo_;
   }
@@ skipping 80 matching lines @@
     RenderDataPiece(name, DataPiece(*string_values_.back(), true));
   }
   return this;
 }
 
 DefaultValueObjectWriter* DefaultValueObjectWriter::RenderBytes(
     StringPiece name, StringPiece value) {
   if (current_ == NULL) {
     ow_->RenderBytes(name, value);
   } else {
-    RenderDataPiece(name, DataPiece(value, false, true));
+    // Since StringPiece is essentially a pointer, takes a copy of "value" to
+    // avoid ownership issues.
+    string_values_.push_back(new string(value.ToString()));
+    RenderDataPiece(name, DataPiece(*string_values_.back(), false, true));
   }
   return this;
 }
 
 DefaultValueObjectWriter* DefaultValueObjectWriter::RenderNull(
     StringPiece name) {
   if (current_ == NULL) {
     ow_->RenderNull(name);
   } else {
     RenderDataPiece(name, DataPiece::NullData());
   }
   return this;
 }
 
 void DefaultValueObjectWriter::RegisterFieldScrubCallBack(
     FieldScrubCallBackPtr field_scrub_callback) {
   field_scrub_callback_.reset(field_scrub_callback.release());
 }
 
-DefaultValueObjectWriter::Node::Node(const string& name,
-                                     const google::protobuf::Type* type,
-                                     NodeKind kind, const DataPiece& data,
-                                     bool is_placeholder,
-                                     const vector<string>& path,
-                                     FieldScrubCallBack* field_scrub_callback)
+DefaultValueObjectWriter::Node::Node(
+    const string& name, const google::protobuf::Type* type, NodeKind kind,
+    const DataPiece& data, bool is_placeholder, const std::vector<string>& path,
+    bool suppress_empty_list, FieldScrubCallBack* field_scrub_callback)
     : name_(name),
       type_(type),
       kind_(kind),
       is_any_(false),
       data_(data),
       is_placeholder_(is_placeholder),
       path_(path),
+      suppress_empty_list_(suppress_empty_list),
       field_scrub_callback_(field_scrub_callback) {}
 
 DefaultValueObjectWriter::Node* DefaultValueObjectWriter::Node::FindChild(
     StringPiece name) {
   if (name.empty() || kind_ != OBJECT) {
     return NULL;
   }
   for (int i = 0; i < children_.size(); ++i) {
     Node* child = children_[i];
     if (child->name() == name) {
@@ skipping 13 matching lines @@
   if (kind_ == MAP) {
     ow->StartObject(name_);
     WriteChildren(ow);
     ow->EndObject();
     return;
   }
 
   // Write out lists. If we didn't have any list in response, write out empty
   // list.
   if (kind_ == LIST) {
+    // Suppress empty lists if requested.
+    if (suppress_empty_list_ && is_placeholder_) return;
+
     ow->StartList(name_);
     WriteChildren(ow);
     ow->EndList();
     return;
   }
 
   // If is_placeholder_ = true, we didn't see this node in the response, so
   // skip output.
   if (is_placeholder_) return;
 
@@ skipping 54 matching lines @@
   // Creates a map of child nodes to speed up lookup.
   for (int i = 0; i < children_.size(); ++i) {
     InsertIfNotPresent(&orig_children_map, children_[i]->name_, i);
   }
 
   for (int i = 0; i < type_->fields_size(); ++i) {
     const google::protobuf::Field& field = type_->fields(i);
 
     // This code is checking if the field to be added to the tree should be
     // scrubbed or not by calling the field_scrub_callback_ callback function.
-    vector<string> path;
+    std::vector<string> path;
     if (!path_.empty()) {
       path.insert(path.begin(), path_.begin(), path_.end());
     }
     path.push_back(field.name());
     if (field_scrub_callback_ != NULL &&
         field_scrub_callback_->Run(path, &field)) {
       continue;
     }
 
     hash_map<string, int>::iterator found =
@@ skipping 41 matching lines @@
     // If oneof_index() != 0, the child field is part of a "oneof", which means
     // the child field is optional and we shouldn't populate its default value.
     if (field.oneof_index() != 0) continue;
 
     // If the child field is of primitive type, sets its data to the default
     // value of its type.
     google::protobuf::scoped_ptr<Node> child(new Node(
         field.json_name(), field_type, kind,
         kind == PRIMITIVE ? CreateDefaultDataPieceForField(field, typeinfo)
                           : DataPiece::NullData(),
-        true, path, field_scrub_callback_));
+        true, path, suppress_empty_list_, field_scrub_callback_));
     new_children.push_back(child.release());
   }
   // Adds all leftover nodes in children_ to the beginning of new_child.
   for (int i = 0; i < children_.size(); ++i) {
     if (children_[i] == NULL) {
       continue;
     }
     new_children.insert(new_children.begin(), children_[i]);
     children_[i] = NULL;
   }
@@ skipping 73 matching lines @@
     case google::protobuf::Field_Kind_TYPE_ENUM: {
       return FindEnumDefault(field, typeinfo);
     }
     default: { return DataPiece::NullData(); }
   }
 }
 
 DefaultValueObjectWriter* DefaultValueObjectWriter::StartObject(
     StringPiece name) {
   if (current_ == NULL) {
-    vector<string> path;
+    std::vector<string> path;
     root_.reset(new Node(name.ToString(), &type_, OBJECT, DataPiece::NullData(),
-                         false, path, field_scrub_callback_.get()));
+                         false, path, suppress_empty_list_,
+                         field_scrub_callback_.get()));
     root_->PopulateChildren(typeinfo_);
     current_ = root_.get();
     return this;
   }
   MaybePopulateChildrenOfAny(current_);
   Node* child = current_->FindChild(name);
   if (current_->kind() == LIST || current_->kind() == MAP || child == NULL) {
     // If current_ is a list or a map node, we should create a new child and use
     // the type of current_ as the type of the new child.
     google::protobuf::scoped_ptr<Node> node(new Node(
         name.ToString(), ((current_->kind() == LIST || current_->kind() == MAP)
                               ? current_->type()
                               : NULL),
         OBJECT, DataPiece::NullData(), false,
         child == NULL ? current_->path() : child->path(),
-        field_scrub_callback_.get()));
+        suppress_empty_list_, field_scrub_callback_.get()));
     child = node.get();
     current_->AddChild(node.release());
   }
 
   child->set_is_placeholder(false);
   if (child->kind() == OBJECT && child->number_of_children() == 0) {
     child->PopulateChildren(typeinfo_);
   }
 
   stack_.push(current_);
   current_ = child;
   return this;
 }
 
 DefaultValueObjectWriter* DefaultValueObjectWriter::EndObject() {
   if (stack_.empty()) {
     // The root object ends here. Writes out the tree.
     WriteRoot();
     return this;
   }
   current_ = stack_.top();
   stack_.pop();
   return this;
 }
 
 DefaultValueObjectWriter* DefaultValueObjectWriter::StartList(
     StringPiece name) {
   if (current_ == NULL) {
-    vector<string> path;
+    std::vector<string> path;
     root_.reset(new Node(name.ToString(), &type_, LIST, DataPiece::NullData(),
-                         false, path, field_scrub_callback_.get()));
+                         false, path, suppress_empty_list_,
+                         field_scrub_callback_.get()));
     current_ = root_.get();
     return this;
   }
   MaybePopulateChildrenOfAny(current_);
   Node* child = current_->FindChild(name);
   if (child == NULL || child->kind() != LIST) {
     google::protobuf::scoped_ptr<Node> node(
         new Node(name.ToString(), NULL, LIST, DataPiece::NullData(), false,
                  child == NULL ? current_->path() : child->path(),
-                 field_scrub_callback_.get()));
+                 suppress_empty_list_, field_scrub_callback_.get()));
     child = node.get();
     current_->AddChild(node.release());
   }
   child->set_is_placeholder(false);
 
   stack_.push(current_);
   current_ = child;
   return this;
 }
 
 void DefaultValueObjectWriter::WriteRoot() {
   root_->WriteTo(ow_);
   root_.reset(NULL);
   current_ = NULL;
 }
 
 DefaultValueObjectWriter* DefaultValueObjectWriter::EndList() {
   if (stack_.empty()) {
     WriteRoot();
     return this;
   }
   current_ = stack_.top();
   stack_.pop();
   return this;
 }
 
 void DefaultValueObjectWriter::RenderDataPiece(StringPiece name,
                                                const DataPiece& data) {
   MaybePopulateChildrenOfAny(current_);
-  util::StatusOr<string> data_string = data.ToString();
   if (current_->type() != NULL && current_->type()->name() == kAnyType &&
-      name == "@type" && data_string.ok()) {
-    const string& string_value = data_string.ValueOrDie();
-    // If the type of current_ is "Any" and its "@type" field is being set here,
-    // sets the type of current_ to be the type specified by the "@type".
-    util::StatusOr<const google::protobuf::Type*> found_type =
-        typeinfo_->ResolveTypeUrl(string_value);
-    if (!found_type.ok()) {
-      GOOGLE_LOG(WARNING) << "Failed to resolve type '" << string_value << "'.";
-    } else {
-      current_->set_type(found_type.ValueOrDie());
-    }
-    current_->set_is_any(true);
-    // If the "@type" field is placed after other fields, we should populate
-    // other children of primitive type now. Otherwise, we should wait until the
-    // first value field is rendered before we populate the children, because
-    // the "value" field of a Any message could be omitted.
-    if (current_->number_of_children() > 1 && current_->type() != NULL) {
-      current_->PopulateChildren(typeinfo_);
+      name == "@type") {
+    util::StatusOr<string> data_string = data.ToString();
+    if (data_string.ok()) {
+      const string& string_value = data_string.ValueOrDie();
+      // If the type of current_ is "Any" and its "@type" field is being set
+      // here, sets the type of current_ to be the type specified by the
+      // "@type".
+      util::StatusOr<const google::protobuf::Type*> found_type =
+          typeinfo_->ResolveTypeUrl(string_value);
+      if (!found_type.ok()) {
+        GOOGLE_LOG(WARNING) << "Failed to resolve type '" << string_value << "'.";
+      } else {
+        current_->set_type(found_type.ValueOrDie());
+      }
+      current_->set_is_any(true);
+      // If the "@type" field is placed after other fields, we should populate
+      // other children of primitive type now. Otherwise, we should wait until
+      // the first value field is rendered before we populate the children,
+      // because the "value" field of a Any message could be omitted.
+      if (current_->number_of_children() > 1 && current_->type() != NULL) {
+        current_->PopulateChildren(typeinfo_);
+      }
     }
   }
   Node* child = current_->FindChild(name);
   if (child == NULL || child->kind() != PRIMITIVE) {
     // No children are found, creates a new child.
     google::protobuf::scoped_ptr<Node> node(
         new Node(name.ToString(), NULL, PRIMITIVE, data, false,
                  child == NULL ? current_->path() : child->path(),
-                 field_scrub_callback_.get()));
-    child = node.get();
+                 suppress_empty_list_, field_scrub_callback_.get()));
     current_->AddChild(node.release());
   } else {
     child->set_data(data);
   }
 }
 
 }  // namespace converter
 }  // namespace util
 }  // namespace protobuf
 }  // namespace google