Reverts third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/src/google/protobuf/reflection_ops.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 @@
 
   const Descriptor* descriptor = from.GetDescriptor();
   GOOGLE_CHECK_EQ(to->GetDescriptor(), descriptor)
     << "Tried to merge messages of different types "
     << "(merge " << descriptor->full_name()
     << " to " << to->GetDescriptor()->full_name() << ")";
 
   const Reflection* from_reflection = from.GetReflection();
   const Reflection* to_reflection = to->GetReflection();
 
-  std::vector<const FieldDescriptor*> fields;
+  vector<const FieldDescriptor*> fields;
   from_reflection->ListFields(from, &fields);
   for (int i = 0; i < fields.size(); i++) {
     const FieldDescriptor* field = fields[i];
 
     if (field->is_repeated()) {
       int count = from_reflection->FieldSize(from, field);
       for (int j = 0; j < count; j++) {
         switch (field->cpp_type()) {
 #define HANDLE_TYPE(CPPTYPE, METHOD)                                     \
           case FieldDescriptor::CPPTYPE_##CPPTYPE:                       \
@@ skipping 45 matching lines @@
     }
   }
 
   to_reflection->MutableUnknownFields(to)->MergeFrom(
     from_reflection->GetUnknownFields(from));
 }
 
 void ReflectionOps::Clear(Message* message) {
   const Reflection* reflection = message->GetReflection();
 
-  std::vector<const FieldDescriptor*> fields;
+  vector<const FieldDescriptor*> fields;
   reflection->ListFields(*message, &fields);
   for (int i = 0; i < fields.size(); i++) {
     reflection->ClearField(message, fields[i]);
   }
 
   reflection->MutableUnknownFields(message)->Clear();
 }
 
 bool ReflectionOps::IsInitialized(const Message& message) {
   const Descriptor* descriptor = message.GetDescriptor();
   const Reflection* reflection = message.GetReflection();
 
   // Check required fields of this message.
   for (int i = 0; i < descriptor->field_count(); i++) {
     if (descriptor->field(i)->is_required()) {
       if (!reflection->HasField(message, descriptor->field(i))) {
         return false;
       }
     }
   }
 
   // Check that sub-messages are initialized.
-  std::vector<const FieldDescriptor*> fields;
+  vector<const FieldDescriptor*> fields;
   reflection->ListFields(message, &fields);
   for (int i = 0; i < fields.size(); i++) {
     const FieldDescriptor* field = fields[i];
     if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
 
       if (field->is_repeated()) {
         int size = reflection->FieldSize(message, field);
 
         for (int j = 0; j < size; j++) {
           if (!reflection->GetRepeatedMessage(message, field, j)
@@ skipping 10 matching lines @@
   }
 
   return true;
 }
 
 void ReflectionOps::DiscardUnknownFields(Message* message) {
   const Reflection* reflection = message->GetReflection();
 
   reflection->MutableUnknownFields(message)->Clear();
 
-  std::vector<const FieldDescriptor*> fields;
+  vector<const FieldDescriptor*> fields;
   reflection->ListFields(*message, &fields);
   for (int i = 0; i < fields.size(); i++) {
     const FieldDescriptor* field = fields[i];
     if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
       if (field->is_repeated()) {
         int size = reflection->FieldSize(*message, field);
         for (int j = 0; j < size; j++) {
           reflection->MutableRepeatedMessage(message, field, j)
                     ->DiscardUnknownFields();
         }
@@ skipping 20 matching lines @@
     result.append(SimpleItoa(index));
     result.append("]");
   }
   result.append(".");
   return result;
 }
 
 void ReflectionOps::FindInitializationErrors(
     const Message& message,
     const string& prefix,
-    std::vector<string>* errors) {
+    vector<string>* errors) {
   const Descriptor* descriptor = message.GetDescriptor();
   const Reflection* reflection = message.GetReflection();
 
   // Check required fields of this message.
   for (int i = 0; i < descriptor->field_count(); i++) {
     if (descriptor->field(i)->is_required()) {
       if (!reflection->HasField(message, descriptor->field(i))) {
         errors->push_back(prefix + descriptor->field(i)->name());
       }
     }
   }
 
   // Check sub-messages.
-  std::vector<const FieldDescriptor*> fields;
+  vector<const FieldDescriptor*> fields;
   reflection->ListFields(message, &fields);
   for (int i = 0; i < fields.size(); i++) {
     const FieldDescriptor* field = fields[i];
     if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
 
       if (field->is_repeated()) {
         int size = reflection->FieldSize(message, field);
 
         for (int j = 0; j < size; j++) {
           const Message& sub_message =
             reflection->GetRepeatedMessage(message, field, j);
           FindInitializationErrors(sub_message,
                                    SubMessagePrefix(prefix, field, j),
                                    errors);
         }
       } else {
         const Message& sub_message = reflection->GetMessage(message, field);
         FindInitializationErrors(sub_message,
                                  SubMessagePrefix(prefix, field, -1),
                                  errors);
       }
     }
   }
 }
 
 }  // namespace internal
 }  // namespace protobuf
 }  // namespace google