third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/util/message_differencer.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 55 matching lines @@
 // When comparing a repeated field as map, MultipleFieldMapKeyComparator can
 // be used to specify multiple fields as key for key comparison.
 // Two elements of a repeated field will be regarded as having the same key
 // iff they have the same value for every specified key field.
 // Note that you can also specify only one field as key.
 class MessageDifferencer::MultipleFieldsMapKeyComparator
     : public MessageDifferencer::MapKeyComparator {
  public:
   MultipleFieldsMapKeyComparator(
       MessageDifferencer* message_differencer,
-      const vector<vector<const FieldDescriptor*> >& key_field_paths)
+      const std::vector<std::vector<const FieldDescriptor*> >& key_field_paths)
         : message_differencer_(message_differencer),
           key_field_paths_(key_field_paths) {
     GOOGLE_CHECK(!key_field_paths_.empty());
     for (int i = 0; i < key_field_paths_.size(); ++i) {
       GOOGLE_CHECK(!key_field_paths_[i].empty());
     }
   }
   MultipleFieldsMapKeyComparator(
       MessageDifferencer* message_differencer,
       const FieldDescriptor* key)
         : message_differencer_(message_differencer) {
-    vector<const FieldDescriptor*> key_field_path;
+    std::vector<const FieldDescriptor*> key_field_path;
     key_field_path.push_back(key);
     key_field_paths_.push_back(key_field_path);
   }
   virtual bool IsMatch(
       const Message& message1,
       const Message& message2,
-      const vector<SpecificField>& parent_fields) const {
+      const std::vector<SpecificField>& parent_fields) const {
     for (int i = 0; i < key_field_paths_.size(); ++i) {
       if (!IsMatchInternal(message1, message2, parent_fields,
                            key_field_paths_[i], 0)) {
         return false;
       }
     }
     return true;
   }
  private:
   bool IsMatchInternal(
       const Message& message1,
       const Message& message2,
-      const vector<SpecificField>& parent_fields,
-      const vector<const FieldDescriptor*>& key_field_path,
+      const std::vector<SpecificField>& parent_fields,
+      const std::vector<const FieldDescriptor*>& key_field_path,
       int path_index) const {
     const FieldDescriptor* field = key_field_path[path_index];
-    vector<SpecificField> current_parent_fields(parent_fields);
+    std::vector<SpecificField> current_parent_fields(parent_fields);
     if (path_index == key_field_path.size() - 1) {
       if (field->is_repeated()) {
         if (!message_differencer_->CompareRepeatedField(
             message1, message2, field, &current_parent_fields)) {
           return false;
         }
       } else {
         if (!message_differencer_->CompareFieldValueUsingParentFields(
             message1, message2, field, -1, -1, &current_parent_fields)) {
           return false;
@@ skipping 16 matching lines @@
       current_parent_fields.push_back(specific_field);
       return IsMatchInternal(
           reflection1->GetMessage(message1, field),
           reflection2->GetMessage(message2, field),
           current_parent_fields,
           key_field_path,
           path_index + 1);
     }
   }
   MessageDifferencer* message_differencer_;
-  vector<vector<const FieldDescriptor*> > key_field_paths_;
+  std::vector<std::vector<const FieldDescriptor*> > key_field_paths_;
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MultipleFieldsMapKeyComparator);
 };
 
 bool MessageDifferencer::Equals(const Message& message1,
                                 const Message& message2) {
   MessageDifferencer differencer;
 
   return differencer.Compare(message1, message2);
 }
 
@@ skipping 116 matching lines @@
       << "Cannot treat this repeated field as both Map and List for "
       << "comparison.";
   MapKeyComparator* key_comparator =
       new MultipleFieldsMapKeyComparator(this, key);
   owned_key_comparators_.push_back(key_comparator);
   map_field_key_comparator_[field] = key_comparator;
 }
 
 void MessageDifferencer::TreatAsMapWithMultipleFieldsAsKey(
     const FieldDescriptor* field,
-    const vector<const FieldDescriptor*>& key_fields) {
-  vector<vector<const FieldDescriptor*> > key_field_paths;
+    const std::vector<const FieldDescriptor*>& key_fields) {
+  std::vector<std::vector<const FieldDescriptor*> > key_field_paths;
   for (int i = 0; i < key_fields.size(); ++i) {
-    vector<const FieldDescriptor*> key_field_path;
+    std::vector<const FieldDescriptor*> key_field_path;
     key_field_path.push_back(key_fields[i]);
     key_field_paths.push_back(key_field_path);
   }
   TreatAsMapWithMultipleFieldPathsAsKey(field, key_field_paths);
 }
 
 void MessageDifferencer::TreatAsMapWithMultipleFieldPathsAsKey(
     const FieldDescriptor* field,
-    const vector<vector<const FieldDescriptor*> >& key_field_paths) {
+    const std::vector<std::vector<const FieldDescriptor*> >& key_field_paths) {
   GOOGLE_CHECK(field->is_repeated()) << "Field must be repeated: "
                               << field->full_name();
   GOOGLE_CHECK_EQ(FieldDescriptor::CPPTYPE_MESSAGE, field->cpp_type())
       << "Field has to be message type.  Field name is: "
       << field->full_name();
   for (int i = 0; i < key_field_paths.size(); ++i) {
-    const vector<const FieldDescriptor*>& key_field_path = key_field_paths[i];
+    const std::vector<const FieldDescriptor*>& key_field_path =
+        key_field_paths[i];
     for (int j = 0; j < key_field_path.size(); ++j) {
       const FieldDescriptor* parent_field =
           j == 0 ? field : key_field_path[j - 1];
       const FieldDescriptor* child_field = key_field_path[j];
       GOOGLE_CHECK(child_field->containing_type() == parent_field->message_type())
           << child_field->full_name()
           << " must be a direct subfield within the field: "
           << parent_field->full_name();
       if (j != 0) {
         GOOGLE_CHECK_EQ(FieldDescriptor::CPPTYPE_MESSAGE, parent_field->cpp_type())
@@ skipping 67 matching lines @@
   if (field2 == NULL) {
     return true;
   }
 
   // Always order fields by their tag number
   return (field1->number() < field2->number());
 }
 
 bool MessageDifferencer::Compare(const Message& message1,
                                  const Message& message2) {
-  vector<SpecificField> parent_fields;
+  std::vector<SpecificField> parent_fields;
 
   bool result = false;
 
   // Setup the internal reporter if need be.
   if (output_string_) {
     io::StringOutputStream output_stream(output_string_);
     StreamReporter reporter(&output_stream);
     reporter_ = &reporter;
     result = Compare(message1, message2, &parent_fields);
     reporter_ = NULL;
   } else {
     result = Compare(message1, message2, &parent_fields);
   }
 
   return result;
 }
 
 bool MessageDifferencer::CompareWithFields(
     const Message& message1,
     const Message& message2,
-    const vector<const FieldDescriptor*>& message1_fields_arg,
-    const vector<const FieldDescriptor*>& message2_fields_arg) {
+    const std::vector<const FieldDescriptor*>& message1_fields_arg,
+    const std::vector<const FieldDescriptor*>& message2_fields_arg) {
   if (message1.GetDescriptor() != message2.GetDescriptor()) {
     GOOGLE_LOG(DFATAL) << "Comparison between two messages with different "
                 << "descriptors.";
     return false;
   }
 
-  vector<SpecificField> parent_fields;
+  std::vector<SpecificField> parent_fields;
 
   bool result = false;
 
-  vector<const FieldDescriptor*> message1_fields(message1_fields_arg);
-  vector<const FieldDescriptor*> message2_fields(message2_fields_arg);
+  std::vector<const FieldDescriptor*> message1_fields(message1_fields_arg);
+  std::vector<const FieldDescriptor*> message2_fields(message2_fields_arg);
 
   std::sort(message1_fields.begin(), message1_fields.end(), FieldBefore);
   std::sort(message2_fields.begin(), message2_fields.end(), FieldBefore);
   // Append NULL sentinel values.
   message1_fields.push_back(NULL);
   message2_fields.push_back(NULL);
 
   // Setup the internal reporter if need be.
   if (output_string_) {
     io::StringOutputStream output_stream(output_string_);
     StreamReporter reporter(&output_stream);
     reporter_ = &reporter;
     result = CompareRequestedFieldsUsingSettings(
         message1, message2, message1_fields, message2_fields, &parent_fields);
     reporter_ = NULL;
   } else {
     result = CompareRequestedFieldsUsingSettings(
         message1, message2, message1_fields, message2_fields, &parent_fields);
   }
 
   return result;
 }
 
 bool MessageDifferencer::Compare(
     const Message& message1,
     const Message& message2,
-    vector<SpecificField>* parent_fields) {
+    std::vector<SpecificField>* parent_fields) {
   const Descriptor* descriptor1 = message1.GetDescriptor();
   const Descriptor* descriptor2 = message2.GetDescriptor();
   if (descriptor1 != descriptor2) {
     GOOGLE_LOG(DFATAL) << "Comparison between two messages with different "
                 << "descriptors. "
                 << descriptor1->full_name() << " vs "
                 << descriptor2->full_name();
     return false;
   }
   // Expand google.protobuf.Any payload if possible.
   if (descriptor1->full_name() == internal::kAnyFullTypeName) {
     google::protobuf::scoped_ptr<Message> data1;
     google::protobuf::scoped_ptr<Message> data2;
     if (UnpackAny(message1, &data1) && UnpackAny(message2, &data2)) {
       return Compare(*data1, *data2, parent_fields);
     }
   }
   const Reflection* reflection1 = message1.GetReflection();
   const Reflection* reflection2 = message2.GetReflection();
 
   // Retrieve all the set fields, including extensions.
-  vector<const FieldDescriptor*> message1_fields;
-  vector<const FieldDescriptor*> message2_fields;
+  std::vector<const FieldDescriptor*> message1_fields;
+  message1_fields.reserve(1 + message1.GetDescriptor()->field_count());
+
+  std::vector<const FieldDescriptor*> message2_fields;
+  message2_fields.reserve(1 + message2.GetDescriptor()->field_count());
 
   reflection1->ListFields(message1, &message1_fields);
   reflection2->ListFields(message2, &message2_fields);
 
   // Add sentinel values to deal with the
   // case where the number of the fields in
   // each list are different.
   message1_fields.push_back(NULL);
   message2_fields.push_back(NULL);
 
@@ skipping 16 matching lines @@
 
   return CompareRequestedFieldsUsingSettings(
       message1, message2,
       message1_fields, message2_fields,
       parent_fields) && unknown_compare_result;
 }
 
 bool MessageDifferencer::CompareRequestedFieldsUsingSettings(
     const Message& message1,
     const Message& message2,
-    const vector<const FieldDescriptor*>& message1_fields,
-    const vector<const FieldDescriptor*>& message2_fields,
-    vector<SpecificField>* parent_fields) {
+    const std::vector<const FieldDescriptor*>& message1_fields,
+    const std::vector<const FieldDescriptor*>& message2_fields,
+    std::vector<SpecificField>* parent_fields) {
   if (scope_ == FULL) {
     if (message_field_comparison_ == EQUIVALENT) {
       // We need to merge the field lists of both messages (i.e.
       // we are merely checking for a difference in field values,
       // rather than the addition or deletion of fields).
-      vector<const FieldDescriptor*> fields_union;
+      std::vector<const FieldDescriptor*> fields_union;
       CombineFields(message1_fields, FULL, message2_fields, FULL,
                     &fields_union);
       return CompareWithFieldsInternal(message1, message2, fields_union,
                                        fields_union, parent_fields);
     } else {
       // Simple equality comparison, use the unaltered field lists.
       return CompareWithFieldsInternal(message1, message2, message1_fields,
                                        message2_fields, parent_fields);
     }
   } else {
     if (message_field_comparison_ == EQUIVALENT) {
       // We use the list of fields for message1 for both messages when
       // comparing.  This way, extra fields in message2 are ignored,
       // and missing fields in message2 use their default value.
       return CompareWithFieldsInternal(message1, message2, message1_fields,
                                        message1_fields, parent_fields);
     } else {
       // We need to consider the full list of fields for message1
       // but only the intersection for message2.  This way, any fields
       // only present in message2 will be ignored, but any fields only
       // present in message1 will be marked as a difference.
-      vector<const FieldDescriptor*> fields_intersection;
+      std::vector<const FieldDescriptor*> fields_intersection;
       CombineFields(message1_fields, PARTIAL, message2_fields, PARTIAL,
                     &fields_intersection);
       return CompareWithFieldsInternal(message1, message2, message1_fields,
                                        fields_intersection, parent_fields);
     }
   }
 }
 
 void MessageDifferencer::CombineFields(
-    const vector<const FieldDescriptor*>& fields1,
+    const std::vector<const FieldDescriptor*>& fields1,
     Scope fields1_scope,
-    const vector<const FieldDescriptor*>& fields2,
+    const std::vector<const FieldDescriptor*>& fields2,
     Scope fields2_scope,
-    vector<const FieldDescriptor*>* combined_fields) {
+    std::vector<const FieldDescriptor*>* combined_fields) {
 
   int index1 = 0;
   int index2 = 0;
 
   while (index1 < fields1.size() && index2 < fields2.size()) {
     const FieldDescriptor* field1 = fields1[index1];
     const FieldDescriptor* field2 = fields2[index2];
 
     if (FieldBefore(field1, field2)) {
       if (fields1_scope == FULL) {
         combined_fields->push_back(fields1[index1]);
       }
       ++index1;
     } else if (FieldBefore(field2, field1)) {
       if (fields2_scope == FULL) {
         combined_fields->push_back(fields2[index2]);
       }
       ++index2;
     } else {
       combined_fields->push_back(fields1[index1]);
       ++index1;
       ++index2;
     }
   }
 }
 
 bool MessageDifferencer::CompareWithFieldsInternal(
     const Message& message1,
     const Message& message2,
-    const vector<const FieldDescriptor*>& message1_fields,
-    const vector<const FieldDescriptor*>& message2_fields,
-    vector<SpecificField>* parent_fields) {
+    const std::vector<const FieldDescriptor*>& message1_fields,
+    const std::vector<const FieldDescriptor*>& message2_fields,
+    std::vector<SpecificField>* parent_fields) {
   bool isDifferent = false;
   int field_index1 = 0;
   int field_index2 = 0;
 
   const Reflection* reflection1 = message1.GetReflection();
   const Reflection* reflection2 = message2.GetReflection();
 
   while (true) {
     const FieldDescriptor* field1 = message1_fields[field_index1];
     const FieldDescriptor* field2 = message2_fields[field_index2];
@@ skipping 15 matching lines @@
 
           parent_fields->push_back(specific_field);
           reporter_->ReportIgnored(message1, message2, *parent_fields);
           parent_fields->pop_back();
         }
         ++field_index1;
         continue;
       }
 
       if (reporter_ != NULL) {
+        assert(field1 != NULL);
         int count = field1->is_repeated() ?
             reflection1->FieldSize(message1, field1) : 1;
 
         for (int i = 0; i < count; ++i) {
           SpecificField specific_field;
           specific_field.field = field1;
           specific_field.index = field1->is_repeated() ? i : -1;
 
           parent_fields->push_back(specific_field);
           reporter_->ReportDeleted(message1, message2, *parent_fields);
@@ skipping 60 matching lines @@
         reporter_->ReportIgnored(message1, message2, *parent_fields);
         parent_fields->pop_back();
       }
 
       ++field_index1;
       ++field_index2;
       continue;
     }
 
     bool fieldDifferent = false;
+    assert(field1 != NULL);
     if (field1->is_repeated()) {
       fieldDifferent = !CompareRepeatedField(message1, message2, field1,
                                              parent_fields);
       if (fieldDifferent) {
         if (reporter_ == NULL) return false;
         isDifferent = true;
       }
     } else {
       fieldDifferent = !CompareFieldValueUsingParentFields(
           message1, message2, field1, -1, -1, parent_fields);
@@ skipping 18 matching lines @@
       }
     }
     // Increment the field indicies.
     ++field_index1;
     ++field_index2;
   }
 
   return !isDifferent;
 }
 
-bool MessageDifferencer::IsMatch(const FieldDescriptor* repeated_field,
-                                 const MapKeyComparator* key_comparator,
-                                 const Message* message1,
-                                 const Message* message2,
-                                 const vector<SpecificField>& parent_fields,
-                                 int index1, int index2) {
-  vector<SpecificField> current_parent_fields(parent_fields);
+bool MessageDifferencer::IsMatch(
+    const FieldDescriptor* repeated_field,
+    const MapKeyComparator* key_comparator, const Message* message1,
+    const Message* message2, const std::vector<SpecificField>& parent_fields,
+    int index1, int index2) {
+  std::vector<SpecificField> current_parent_fields(parent_fields);
   if (repeated_field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
     return CompareFieldValueUsingParentFields(
         *message1, *message2, repeated_field, index1, index2,
         &current_parent_fields);
   }
   // Back up the Reporter and output_string_.  They will be reset in the
   // following code.
   Reporter* backup_reporter = reporter_;
   string* output_string = output_string_;
   reporter_ = NULL;
@@ skipping 19 matching lines @@
 
   reporter_ = backup_reporter;
   output_string_ = output_string;
   return match;
 }
 
 bool MessageDifferencer::CompareRepeatedField(
     const Message& message1,
     const Message& message2,
     const FieldDescriptor* repeated_field,
-    vector<SpecificField>* parent_fields) {
+    std::vector<SpecificField>* parent_fields) {
   // the input FieldDescriptor is guaranteed to be repeated field.
   const Reflection* reflection1 = message1.GetReflection();
   const Reflection* reflection2 = message2.GetReflection();
   const int count1 = reflection1->FieldSize(message1, repeated_field);
   const int count2 = reflection2->FieldSize(message2, repeated_field);
   const bool treated_as_subset = IsTreatedAsSubset(repeated_field);
 
   // If the field is not treated as subset and no detailed reports is needed,
   // we do a quick check on the number of the elements to avoid unnecessary
   // comparison.
   if (count1 != count2 && reporter_ == NULL && !treated_as_subset) {
     return false;
   }
   // A match can never be found if message1 has more items than message2.
   if (count1 > count2 && reporter_ == NULL) {
     return false;
   }
 
   // These two list are used for store the index of the correspondent
   // element in peer repeated field.
-  vector<int> match_list1;
-  vector<int> match_list2;
+  std::vector<int> match_list1;
+  std::vector<int> match_list2;
 
   // Try to match indices of the repeated fields. Return false if match fails
   // and there's no detailed report needed.
   if (!MatchRepeatedFieldIndices(message1, message2, repeated_field,
                                  *parent_fields, &match_list1, &match_list2) &&
       reporter_ == NULL) {
     return false;
   }
 
   bool fieldDifferent = false;
@@ skipping 42 matching lines @@
     if (reporter_ == NULL) continue;
     specific_field.index = i;
     specific_field.new_index = i;
     parent_fields->push_back(specific_field);
     reporter_->ReportAdded(message1, message2, *parent_fields);
     parent_fields->pop_back();
   }
 
   for (int i = 0; i < count1; ++i) {
     if (match_list1[i] != -1) continue;
+    assert(reporter_ != NULL);
     specific_field.index = i;
     parent_fields->push_back(specific_field);
     reporter_->ReportDeleted(message1, message2, *parent_fields);
     parent_fields->pop_back();
     fieldDifferent = true;
   }
   return !fieldDifferent;
 }
 
 bool MessageDifferencer::CompareFieldValue(const Message& message1,
                                            const Message& message2,
                                            const FieldDescriptor* field,
                                            int index1,
                                            int index2) {
   return CompareFieldValueUsingParentFields(message1, message2, field, index1,
                                             index2, NULL);
 }
 
 bool MessageDifferencer::CompareFieldValueUsingParentFields(
     const Message& message1, const Message& message2,
     const FieldDescriptor* field, int index1, int index2,
-    vector<SpecificField>* parent_fields) {
+    std::vector<SpecificField>* parent_fields) {
   FieldContext field_context(parent_fields);
   FieldComparator::ComparisonResult result = GetFieldComparisonResult(
       message1, message2, field, index1, index2, &field_context);
 
   if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
       result == FieldComparator::RECURSE) {
     // Get the nested messages and compare them using one of the Compare
     // methods.
     const Reflection* reflection1 = message1.GetReflection();
     const Reflection* reflection2 = message2.GetReflection();
@@ skipping 18 matching lines @@
     } else {
       // Recreates parent_fields as if m1 and m2 had no parents.
       return Compare(m1, m2);
     }
   } else {
     return (result == FieldComparator::SAME);
   }
 }
 
 bool MessageDifferencer::CheckPathChanged(
-    const vector<SpecificField>& field_path) {
+    const std::vector<SpecificField>& field_path) {
   for (int i = 0; i < field_path.size(); ++i) {
     if (field_path[i].index != field_path[i].new_index) return true;
   }
   return false;
 }
 
 bool MessageDifferencer::IsTreatedAsSet(const FieldDescriptor* field) {
   if (!field->is_repeated()) return false;
   if (field->is_map()) return true;
   if (repeated_field_comparison_ == AS_SET)
     return list_fields_.find(field) == list_fields_.end();
   return (set_fields_.find(field) != set_fields_.end());
 }
 
 bool MessageDifferencer::IsTreatedAsSubset(const FieldDescriptor* field) {
   return scope_ == PARTIAL &&
       (IsTreatedAsSet(field) || GetMapKeyComparator(field) != NULL);
 }
 
 bool MessageDifferencer::IsIgnored(
     const Message& message1,
     const Message& message2,
     const FieldDescriptor* field,
-    const vector<SpecificField>& parent_fields) {
+    const std::vector<SpecificField>& parent_fields) {
   if (ignored_fields_.find(field) != ignored_fields_.end()) {
     return true;
   }
   for (int i = 0; i < ignore_criteria_.size(); ++i) {
     if (ignore_criteria_[i]->IsIgnored(message1, message2, field,
                                        parent_fields)) {
       return true;
     }
   }
   return false;
 }
 
 bool MessageDifferencer::IsUnknownFieldIgnored(
     const Message& message1, const Message& message2,
-    const SpecificField& field, const vector<SpecificField>& parent_fields) {
+    const SpecificField& field,
+    const std::vector<SpecificField>& parent_fields) {
   for (int i = 0; i < ignore_criteria_.size(); ++i) {
     if (ignore_criteria_[i]->IsUnknownFieldIgnored(message1, message2, field,
                                                    parent_fields)) {
       return true;
     }
   }
   return false;
 }
 
 const MessageDifferencer::MapKeyComparator* MessageDifferencer
     ::GetMapKeyComparator(const FieldDescriptor* field) {
   if (!field->is_repeated()) return NULL;
   if (map_field_key_comparator_.find(field) !=
       map_field_key_comparator_.end()) {
     return map_field_key_comparator_[field];
   }
   return NULL;
 }
 
 namespace {
 
-typedef pair<int, const UnknownField*> IndexUnknownFieldPair;
+typedef std::pair<int, const UnknownField*> IndexUnknownFieldPair;
 
 struct UnknownFieldOrdering {
   inline bool operator()(const IndexUnknownFieldPair& a,
                          const IndexUnknownFieldPair& b) const {
     if (a.second->number() < b.second->number()) return true;
     if (a.second->number() > b.second->number()) return false;
     return a.second->type() < b.second->type();
   }
 };
 
@@ skipping 30 matching lines @@
     GOOGLE_DLOG(ERROR) << "Failed to parse value for " << full_type_name;
     return false;
   }
   return true;
 }
 
 bool MessageDifferencer::CompareUnknownFields(
     const Message& message1, const Message& message2,
     const google::protobuf::UnknownFieldSet& unknown_field_set1,
     const google::protobuf::UnknownFieldSet& unknown_field_set2,
-    vector<SpecificField>* parent_field) {
+    std::vector<SpecificField>* parent_field) {
   // Ignore unknown fields in EQUIVALENT mode.
   if (message_field_comparison_ == EQUIVALENT) return true;
 
   if (unknown_field_set1.empty() && unknown_field_set2.empty()) {
     return true;
   }
 
   bool is_different = false;
 
   // We first sort the unknown fields by field number and type (in other words,
   // in tag order), making sure to preserve ordering of values with the same
   // tag.  This allows us to report only meaningful differences between the
   // two sets -- that is, differing values for the same tag.  We use
   // IndexUnknownFieldPairs to keep track of the field's original index for
   // reporting purposes.
-  vector<IndexUnknownFieldPair> fields1;  // unknown_field_set1, sorted
-  vector<IndexUnknownFieldPair> fields2;  // unknown_field_set2, sorted
+  std::vector<IndexUnknownFieldPair> fields1;  // unknown_field_set1, sorted
+  std::vector<IndexUnknownFieldPair> fields2;  // unknown_field_set2, sorted
   fields1.reserve(unknown_field_set1.field_count());
   fields2.reserve(unknown_field_set2.field_count());
 
   for (int i = 0; i < unknown_field_set1.field_count(); i++) {
     fields1.push_back(std::make_pair(i, &unknown_field_set1.field(i)));
   }
   for (int i = 0; i < unknown_field_set2.field_count(); i++) {
     fields2.push_back(std::make_pair(i, &unknown_field_set2.field(i)));
   }
 
@@ skipping 182 matching lines @@
   // determine whether a node on the left side of the bipartial graph matches
   // a node on the right side. count1 is the number of nodes on the left side
   // of the graph and count2 to is the number of nodes on the right side.
   // Every node is referred to using 0-based indices.
   // If a maximum match is found, the result will be stored in match_list1 and
   // match_list2. match_list1[i] == j means the i-th node on the left side is
   // matched to the j-th node on the right side and match_list2[x] == y means
   // the x-th node on the right side is matched to y-th node on the left side.
   // match_list1[i] == -1 means the node is not matched. Same with match_list2.
   MaximumMatcher(int count1, int count2, NodeMatchCallback* callback,
-                 vector<int>* match_list1, vector<int>* match_list2);
+                 std::vector<int>* match_list1, std::vector<int>* match_list2);
   // Find a maximum match and return the number of matched node pairs.
   // If early_return is true, this method will return 0 immediately when it
   // finds that not all nodes on the left side can be matched.
   int FindMaximumMatch(bool early_return);
  private:
   // Determines whether the node on the left side of the bipartial graph
   // matches the one on the right side.
   bool Match(int left, int right);
   // Find an argumenting path starting from the node v on the left side. If a
   // path can be found, update match_list2_ to reflect the path and return
   // true.
-  bool FindArgumentPathDFS(int v, vector<bool>* visited);
+  bool FindArgumentPathDFS(int v, std::vector<bool>* visited);
 
   int count1_;
   int count2_;
   google::protobuf::scoped_ptr<NodeMatchCallback> match_callback_;
-  map<pair<int, int>, bool> cached_match_results_;
-  vector<int>* match_list1_;
-  vector<int>* match_list2_;
+  std::map<std::pair<int, int>, bool> cached_match_results_;
+  std::vector<int>* match_list1_;
+  std::vector<int>* match_list2_;
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MaximumMatcher);
 };
 
 MaximumMatcher::MaximumMatcher(int count1, int count2,
                                NodeMatchCallback* callback,
-                               vector<int>* match_list1,
-                               vector<int>* match_list2)
+                               std::vector<int>* match_list1,
+                               std::vector<int>* match_list2)
     : count1_(count1), count2_(count2), match_callback_(callback),
       match_list1_(match_list1), match_list2_(match_list2) {
   match_list1_->assign(count1, -1);
   match_list2_->assign(count2, -1);
 }
 
 int MaximumMatcher::FindMaximumMatch(bool early_return) {
   int result = 0;
   for (int i = 0; i < count1_; ++i) {
-    vector<bool> visited(count1_);
+    std::vector<bool> visited(count1_);
     if (FindArgumentPathDFS(i, &visited)) {
       ++result;
     } else if (early_return) {
       return 0;
     }
   }
   // Backfill match_list1_ as we only filled match_list2_ when finding
   // argumenting pathes.
   for (int i = 0; i < count2_; ++i) {
     if ((*match_list2_)[i] != -1) {
       (*match_list1_)[(*match_list2_)[i]] = i;
     }
   }
   return result;
 }
 
 bool MaximumMatcher::Match(int left, int right) {
-  pair<int, int> p(left, right);
-  map<pair<int, int>, bool>::iterator it = cached_match_results_.find(p);
+  std::pair<int, int> p(left, right);
+  std::map<std::pair<int, int>, bool>::iterator it =
+      cached_match_results_.find(p);
   if (it != cached_match_results_.end()) {
     return it->second;
   }
   cached_match_results_[p] = match_callback_->Run(left, right);
   return cached_match_results_[p];
 }
 
-bool MaximumMatcher::FindArgumentPathDFS(int v, vector<bool>* visited) {
+bool MaximumMatcher::FindArgumentPathDFS(int v, std::vector<bool>* visited) {
   (*visited)[v] = true;
   // We try to match those un-matched nodes on the right side first. This is
   // the step that the navie greedy matching algorithm uses. In the best cases
   // where the greedy algorithm can find a maximum matching, we will always
   // find a match in this step and the performance will be identical to the
   // greedy algorithm.
   for (int i = 0; i < count2_; ++i) {
     int matched = (*match_list2_)[i];
     if (matched == -1 && Match(v, i)) {
       (*match_list2_)[i] = v;
@@ skipping 15 matching lines @@
   }
   return false;
 }
 
 }  // namespace
 
 bool MessageDifferencer::MatchRepeatedFieldIndices(
     const Message& message1,
     const Message& message2,
     const FieldDescriptor* repeated_field,
-    const vector<SpecificField>& parent_fields,
-    vector<int>* match_list1,
-    vector<int>* match_list2) {
+    const std::vector<SpecificField>& parent_fields,
+    std::vector<int>* match_list1,
+    std::vector<int>* match_list2) {
   const int count1 =
       message1.GetReflection()->FieldSize(message1, repeated_field);
   const int count2 =
       message2.GetReflection()->FieldSize(message2, repeated_field);
   const MapKeyComparator* key_comparator = GetMapKeyComparator(repeated_field);
 
   match_list1->assign(count1, -1);
   match_list2->assign(count2, -1);
 
   SpecificField specific_field;
   specific_field.field = repeated_field;
 
   bool success = true;
   // Find potential match if this is a special repeated field.
   if (key_comparator != NULL || IsTreatedAsSet(repeated_field)) {
     if (scope_ == PARTIAL) {
       // When partial matching is enabled, Compare(a, b) && Compare(a, c)
-      // doesn't neccessarily imply Compare(b, c). Therefore a naive greedy
+      // doesn't necessarily imply Compare(b, c). Therefore a naive greedy
       // algorithm will fail to find a maximum matching.
       // Here we use the argumenting path algorithm.
       MaximumMatcher::NodeMatchCallback* callback =
-          ::google::protobuf::internal::NewPermanentCallback(
+          NewPermanentCallback(
               this, &MessageDifferencer::IsMatch,
               repeated_field, key_comparator,
               &message1, &message2, parent_fields);
       MaximumMatcher matcher(count1, count2, callback, match_list1,
                              match_list2);
       // If diff info is not needed, we should end the matching process as
       // soon as possible if not all items can be matched.
       bool early_return = (reporter_ == NULL);
       int match_count = matcher.FindMaximumMatch(early_return);
       if (match_count != count1 && reporter_ == NULL) return false;
@@ skipping 72 matching lines @@
 MessageDifferencer::StreamReporter::StreamReporter(
     io::Printer* printer) : printer_(printer),
                             delete_printer_(false),
                             report_modified_aggregates_(false) { }
 
 MessageDifferencer::StreamReporter::~StreamReporter() {
   if (delete_printer_) delete printer_;
 }
 
 void MessageDifferencer::StreamReporter::PrintPath(
-    const vector<SpecificField>& field_path, bool left_side) {
+    const std::vector<SpecificField>& field_path, bool left_side) {
   for (int i = 0; i < field_path.size(); ++i) {
     if (i > 0) {
       printer_->Print(".");
     }
 
     SpecificField specific_field = field_path[i];
 
     if (specific_field.field != NULL) {
       if (specific_field.field->is_extension()) {
         printer_->Print("($name$)", "name",
                         specific_field.field->full_name());
       } else {
         printer_->PrintRaw(specific_field.field->name());
       }
     } else {
       printer_->PrintRaw(SimpleItoa(specific_field.unknown_field_number));
     }
     if (left_side && specific_field.index >= 0) {
       printer_->Print("[$name$]", "name", SimpleItoa(specific_field.index));
     }
     if (!left_side && specific_field.new_index >= 0) {
       printer_->Print("[$name$]", "name", SimpleItoa(specific_field.new_index));
     }
   }
 }
 
 void MessageDifferencer::
 StreamReporter::PrintValue(const Message& message,
-                           const vector<SpecificField>& field_path,
+                           const std::vector<SpecificField>& field_path,
                            bool left_side) {
   const SpecificField& specific_field = field_path.back();
   const FieldDescriptor* field = specific_field.field;
   if (field != NULL) {
     string output;
     int index = left_side ? specific_field.index : specific_field.new_index;
     if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
       const Reflection* reflection = message.GetReflection();
       const Message& field_message = field->is_repeated() ?
           reflection->GetRepeatedMessage(message, field, index) :
@@ skipping 52 matching lines @@
   printer_->PrintRaw(output);
 }
 
 void MessageDifferencer::StreamReporter::Print(const string& str) {
   printer_->Print(str.c_str());
 }
 
 void MessageDifferencer::StreamReporter::ReportAdded(
     const Message& message1,
     const Message& message2,
-    const vector<SpecificField>& field_path) {
+    const std::vector<SpecificField>& field_path) {
   printer_->Print("added: ");
   PrintPath(field_path, false);
   printer_->Print(": ");
   PrintValue(message2, field_path, false);
   printer_->Print("\n");  // Print for newlines.
 }
 
 void MessageDifferencer::StreamReporter::ReportDeleted(
     const Message& message1,
     const Message& message2,
-    const vector<SpecificField>& field_path) {
+    const std::vector<SpecificField>& field_path) {
   printer_->Print("deleted: ");
   PrintPath(field_path, true);
   printer_->Print(": ");
   PrintValue(message1, field_path, true);
   printer_->Print("\n");  // Print for newlines
 }
 
 void MessageDifferencer::StreamReporter::ReportModified(
     const Message& message1,
     const Message& message2,
-    const vector<SpecificField>& field_path) {
+    const std::vector<SpecificField>& field_path) {
   if (!report_modified_aggregates_ && field_path.back().field == NULL) {
     if (field_path.back().unknown_field_type == UnknownField::TYPE_GROUP) {
       // Any changes to the subfields have already been printed.
       return;
     }
   } else if (!report_modified_aggregates_) {
     if (field_path.back().field->cpp_type() ==
         FieldDescriptor::CPPTYPE_MESSAGE) {
       // Any changes to the subfields have already been printed.
       return;
     }
   }
 
   printer_->Print("modified: ");
   PrintPath(field_path, true);
   if (CheckPathChanged(field_path)) {
     printer_->Print(" -> ");
     PrintPath(field_path, false);
   }
   printer_->Print(": ");
   PrintValue(message1, field_path, true);
   printer_->Print(" -> ");
   PrintValue(message2, field_path, false);
   printer_->Print("\n");  // Print for newlines.
 }
 
 void MessageDifferencer::StreamReporter::ReportMoved(
     const Message& message1,
     const Message& message2,
-    const vector<SpecificField>& field_path) {
+    const std::vector<SpecificField>& field_path) {
   printer_->Print("moved: ");
   PrintPath(field_path, true);
   printer_->Print(" -> ");
   PrintPath(field_path, false);
   printer_->Print(" : ");
   PrintValue(message1, field_path, true);
   printer_->Print("\n");  // Print for newlines.
 }
 
 void MessageDifferencer::StreamReporter::ReportMatched(
     const Message& message1,
     const Message& message2,
-    const vector<SpecificField>& field_path) {
+    const std::vector<SpecificField>& field_path) {
   printer_->Print("matched: ");
   PrintPath(field_path, true);
   if (CheckPathChanged(field_path)) {
     printer_->Print(" -> ");
     PrintPath(field_path, false);
   }
   printer_->Print(" : ");
   PrintValue(message1, field_path, true);
   printer_->Print("\n");  // Print for newlines.
 }
 
 void MessageDifferencer::StreamReporter::ReportIgnored(
     const Message& message1,
     const Message& message2,
-    const vector<SpecificField>& field_path) {
+    const std::vector<SpecificField>& field_path) {
   printer_->Print("ignored: ");
   PrintPath(field_path, true);
   if (CheckPathChanged(field_path)) {
     printer_->Print(" -> ");
     PrintPath(field_path, false);
   }
   printer_->Print("\n");  // Print for newlines.
 }
 
 void MessageDifferencer::StreamReporter::ReportUnknownFieldIgnored(
     const Message& message1, const Message& message2,
-    const vector<SpecificField>& field_path) {
+    const std::vector<SpecificField>& field_path) {
   printer_->Print("ignored: ");
   PrintPath(field_path, true);
   if (CheckPathChanged(field_path)) {
     printer_->Print(" -> ");
     PrintPath(field_path, false);
   }
   printer_->Print("\n");  // Print for newlines.
 }
 
 }  // namespace util
 }  // namespace protobuf
 }  // namespace google