[CleanUp] Use base::STLSetDifference in place of std::set_difference

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 <functional>
 
 #include "base/file_util.h"
 #include "base/files/important_file_writer.h"
@@ skipping 111 matching lines @@
   base::CopyFile(path, path.AddExtension(BACKUP_EXTENSION));
   base::ImportantFileWriter::WriteFileAtomically(path, content.str());
 }
 
 // Removes duplicate and invalid words from |to_add| word list and sorts it.
 // Looks for duplicates in both |to_add| and |existing| word lists. Returns a
 // bitmap of |ChangeSanitationResult| values.
 int SanitizeWordsToAdd(const WordSet& existing, WordList& to_add) {
   // Do not add duplicate words.
   std::sort(to_add.begin(), to_add.end());
-  WordList new_words;
-  std::set_difference(to_add.begin(),
-                      to_add.end(),
-                      existing.begin(),
-                      existing.end(),
-                      std::back_inserter(new_words));
+  WordList new_words = base::STLSetDifference<WordList>(to_add, existing);
   new_words.erase(std::unique(new_words.begin(), new_words.end()),
                   new_words.end());
   int result = VALID_CHANGE;
   if (to_add.size() != new_words.size())
     result |= DETECTED_DUPLICATE_WORDS;
   // Do not add invalid words.
   size_t size = new_words.size();
   new_words.erase(std::remove_if(new_words.begin(),
                                  new_words.end(),
                                  IsInvalidWord),
@@ skipping 173 matching lines @@
 
   // Add remote words locally.
   Change to_change_locally(to_add_locally);
   to_change_locally.Sanitize(GetWords());
   Apply(to_change_locally);
   Notify(to_change_locally);
   Save(to_change_locally);
 
   // Add as many as possible local words remotely.
   std::sort(to_add_locally.begin(), to_add_locally.end());
-  WordList to_add_remotely;
-  std::set_difference(words_.begin(),
-                      words_.end(),
-                      to_add_locally.begin(),
-                      to_add_locally.end(),
-                      std::back_inserter(to_add_remotely));
+  WordList to_add_remotely = base::STLSetDifference<WordList>(words_,
+                                                              to_add_locally);
 
   // Send local changes to the sync server.
   Change to_change_remotely(to_add_remotely);
   syncer::SyncMergeResult result(type);
   result.set_error(Sync(to_change_remotely));
   return result;
 }
 
 void SpellcheckCustomDictionary::StopSyncing(syncer::ModelType type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 77 matching lines @@
   WordList custom_words;
   LoadDictionaryFileReliably(custom_words, path);
 
   // Add words.
   custom_words.insert(custom_words.end(),
                       dictionary_change.to_add().begin(),
                       dictionary_change.to_add().end());
 
   // Remove words.
   std::sort(custom_words.begin(), custom_words.end());
-  WordList remaining;
-  std::set_difference(custom_words.begin(),
-                      custom_words.end(),
-                      dictionary_change.to_remove().begin(),
-                      dictionary_change.to_remove().end(),
-                      std::back_inserter(remaining));
+  WordList remaining =
+      base::STLSetDifference<WordList>(custom_words,
+                                       dictionary_change.to_remove());
   std::swap(custom_words, remaining);
 
   SaveDictionaryFileReliably(custom_words, path);
 }
 
 void SpellcheckCustomDictionary::OnLoaded(WordList custom_words) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   Change dictionary_change(custom_words);
   dictionary_change.Sanitize(GetWords());
   Apply(dictionary_change);
@@ skipping 92 matching lines @@
 
 void SpellcheckCustomDictionary::Notify(
     const SpellcheckCustomDictionary::Change& dictionary_change) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!IsLoaded() || dictionary_change.empty())
     return;
   FOR_EACH_OBSERVER(Observer,
                     observers_,
                     OnCustomDictionaryChanged(dictionary_change));
 }