Make flat containers stable, allow constructing from vector.

components/omnibox/browser/url_index_private_data.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/omnibox/browser/url_index_private_data.h"
 
 #include <stdint.h>
 
 #include <functional>
 #include <iterator>
@@ skipping 586 matching lines @@
   // construct a flat_set than to insert elements one by one.
   HistoryIDVector buffer;
   for (WordID word_id : word_id_set) {
     WordIDHistoryMap::iterator word_iter = word_id_history_map_.find(word_id);
     if (word_iter != word_id_history_map_.end()) {
       HistoryIDSet& word_history_id_set(word_iter->second);
       buffer.insert(buffer.end(), word_history_id_set.begin(),
                     word_history_id_set.end());
     }
   }
-  HistoryIDSet history_id_set(buffer.begin(), buffer.end());
+  HistoryIDSet history_id_set(buffer.begin(), buffer.end(),
+                              base::KEEP_FIRST_OF_DUPES);
 
   // Record a new cache entry for this word if the term is longer than
   // a single character.
   if (term_length > 1)
     search_term_cache_[term] = SearchTermCacheItem(word_id_set, history_id_set);
 
   return history_id_set;
 }
 
 WordIDSet URLIndexPrivateData::WordIDSetForTermChars(
@@ skipping 469 matching lines @@
   if (actual_item_count == 0 || actual_item_count != expected_item_count)
     return false;
 
   for (const auto& entry : list_item.char_word_map_entry()) {
     expected_item_count = entry.item_count();
     actual_item_count = entry.word_id_size();
     if (actual_item_count == 0 || actual_item_count != expected_item_count)
       return false;
     base::char16 uni_char = static_cast<base::char16>(entry.char_16());
     const RepeatedField<int32_t>& word_ids = entry.word_id();
-    char_word_map_[uni_char] = {word_ids.begin(), word_ids.end()};
+    char_word_map_[uni_char] =
+        WordIDSet(word_ids.begin(), word_ids.end(), base::KEEP_FIRST_OF_DUPES);
   }
   return true;
 }
 
 bool URLIndexPrivateData::RestoreWordIDHistoryMap(
     const InMemoryURLIndexCacheItem& cache) {
   if (!cache.has_word_id_history_map())
     return false;
   const WordIDHistoryMapItem& list_item(cache.word_id_history_map());
   uint32_t expected_item_count = list_item.item_count();
   uint32_t actual_item_count = list_item.word_id_history_map_entry_size();
   if (actual_item_count == 0 || actual_item_count != expected_item_count)
     return false;
   for (const auto& entry : list_item.word_id_history_map_entry()) {
     expected_item_count = entry.item_count();
     actual_item_count = entry.history_id_size();
     if (actual_item_count == 0 || actual_item_count != expected_item_count)
       return false;
     WordID word_id = entry.word_id();
     const RepeatedField<int64_t>& history_ids = entry.history_id();
-    word_id_history_map_[word_id] = {history_ids.begin(), history_ids.end()};
+    word_id_history_map_[word_id] = HistoryIDSet(
+        history_ids.begin(), history_ids.end(), base::KEEP_FIRST_OF_DUPES);
     for (HistoryID history_id : history_ids)
       history_id_word_map_[history_id].insert(word_id);
   }
   return true;
 }
 
 bool URLIndexPrivateData::RestoreHistoryInfoMap(
     const InMemoryURLIndexCacheItem& cache) {
   if (!cache.has_history_info_map())
     return false;
@@ skipping 139 matching lines @@
   // First cut: typed count, visit count, recency.
   // TODO(mrossetti): This is too simplistic. Consider an approach which ranks
   // recently visited (within the last 12/24 hours) as highly important. Get
   // input from mpearson.
   if (r1.typed_count() != r2.typed_count())
     return (r1.typed_count() > r2.typed_count());
   if (r1.visit_count() != r2.visit_count())
     return (r1.visit_count() > r2.visit_count());
   return (r1.last_visit() > r2.last_visit());
 }