Cheer up spell-checking code

chrome/browser/spellchecker/spellcheck_custom_dictionary.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 "chrome/browser/spellchecker/spellcheck_custom_dictionary.h"
 
 #include <stddef.h>
 #include <functional>
 #include <utility>
 
@@ skipping 78 matching lines @@
              base::TrimWhitespaceASCII(word, base::TRIM_ALL, &tmp);
 }
 
 // Removes duplicate and invalid words from |to_add| word list. Looks for
 // duplicates in both |to_add| and |existing| word lists. Returns a bitmap of
 // |ChangeSanitationResult| values.
 int SanitizeWordsToAdd(const std::set<std::string>& existing,
                        std::set<std::string>* to_add) {
   DCHECK(to_add);
   // Do not add duplicate words.
-  std::set<std::string> new_words =
-      base::STLSetDifference<std::set<std::string>>(*to_add, existing);
+  std::vector<std::string> new_words =
+      base::STLSetDifference<std::vector<std::string>>(*to_add, existing);
   int result = VALID_CHANGE;
   if (to_add->size() != new_words.size())
     result |= DETECTED_DUPLICATE_WORDS;
   // Do not add invalid words.
   std::set<std::string> valid_new_words;
-  for (const std::string& word : new_words) {
+  for (const auto& word : new_words) {
     if (IsValidWord(word))
       valid_new_words.insert(valid_new_words.end(), word);
   }
   if (valid_new_words.size() != new_words.size())
     result |= DETECTED_INVALID_WORDS;
   // Save the sanitized words to be added.
   std::swap(*to_add, valid_new_words);
   return result;
 }
 
@@ skipping 209 matching lines @@
   DCHECK_EQ(syncer::DICTIONARY, type);
   sync_processor_.reset();
   sync_error_handler_.reset();
 }
 
 syncer::SyncDataList SpellcheckCustomDictionary::GetAllSyncData(
     syncer::ModelType type) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(syncer::DICTIONARY, type);
   syncer::SyncDataList data;
-  std::string word;
   size_t i = 0;
-  for (auto it = words_.begin();
-       it != words_.end() &&
-       i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
-       ++it, ++i) {
-    word = *it;
+  for (const auto& word : words_) {
+    if (i++ >= chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS)
+      break;
     sync_pb::EntitySpecifics specifics;
     specifics.mutable_dictionary()->set_word(word);
     data.push_back(syncer::SyncData::CreateLocalData(word, word, specifics));
   }
   return data;
 }
 
 syncer::SyncError SpellcheckCustomDictionary::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& change_list) {
@@ skipping 85 matching lines @@
         fix_invalid_file_.callback());
   }
 }
 
 void SpellcheckCustomDictionary::Apply(const Change& dictionary_change) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!dictionary_change.to_add().empty()) {
     words_.insert(dictionary_change.to_add().begin(),
                   dictionary_change.to_add().end());
   }
-  if (!dictionary_change.to_remove().empty()) {
-    std::set<std::string> updated_words =
-        base::STLSetDifference<std::set<std::string>>(
-            words_, dictionary_change.to_remove());
-    std::swap(words_, updated_words);
-  }
+  for (const auto& word : dictionary_change.to_remove())
+    words_.erase(word);
 }
 
 void SpellcheckCustomDictionary::FixInvalidFile(
     scoped_ptr<LoadFileResult> load_file_result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&SavePassedWordsToDictionaryFileReliably,
                  custom_dictionary_path_, base::Passed(&load_file_result)));
 }
@@ skipping 22 matching lines @@
       static_cast<int>(
           chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS) -
           server_size);
   int upload_size = std::min(
       static_cast<int>(dictionary_change.to_add().size()),
       max_upload_size);
 
   syncer::SyncChangeList sync_change_list;
   int i = 0;
 
-  for (auto it = dictionary_change.to_add().begin();
-       it != dictionary_change.to_add().end() && i < upload_size; ++it, ++i) {
-    const std::string& word = *it;
+  for (const auto& word : dictionary_change.to_add()) {
+    if (i++ >= upload_size)
+      break;
     sync_pb::EntitySpecifics specifics;
     specifics.mutable_dictionary()->set_word(word);
     sync_change_list.push_back(syncer::SyncChange(
         FROM_HERE, syncer::SyncChange::ACTION_ADD,
         syncer::SyncData::CreateLocalData(word, word, specifics)));
   }
 
   for (const std::string& word : dictionary_change.to_remove()) {
     sync_pb::EntitySpecifics specifics;
     specifics.mutable_dictionary()->set_word(word);
@@ skipping 17 matching lines @@
 }
 
 void SpellcheckCustomDictionary::Notify(const Change& dictionary_change) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!IsLoaded() || dictionary_change.empty())
     return;
   FOR_EACH_OBSERVER(Observer,
                     observers_,
                     OnCustomDictionaryChanged(dictionary_change));
 }