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

chrome/browser/spellchecker/feedback.cc

 // Copyright (c) 2013 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.
 //
 // The |Feedback| object keeps track of each instance of user feedback in a map
 // |misspellings_|. This is a map from uint32 hashes to |Misspelling| objects.
 //
 // Each misspelling should be present in only one renderer process. The
 // |Feedback| objects keeps track of misspelling-renderer relationship in the
 // |renderers_| map of renderer process identifiers to a set of hashes.
 //
 // When the user adds a misspelling to their custom dictionary, all of the
 // |Misspelling| objects with the same misspelled string are updated. The
 // |Feedback| object facilitates efficient access to these misspellings through
 // a |text_| map of misspelled strings to a set of hashes.
 
 #include "chrome/browser/spellchecker/feedback.h"
 
 #include <algorithm>
 #include <iterator>
 
+#include "base/stl_util.h"
+
 namespace spellcheck {
 
 Feedback::Feedback() {
 }
 
 Feedback::~Feedback() {
 }
 
 Misspelling* Feedback::GetMisspelling(uint32 hash) {
   HashMisspellingMap::iterator misspelling_it = misspellings_.find(hash);
   if (misspelling_it == misspellings_.end())
     return NULL;
   return &misspelling_it->second;
 }
 
 void Feedback::FinalizeRemovedMisspellings(
     int renderer_process_id,
     const std::vector<uint32>& remaining_markers) {
   RendererHashesMap::iterator renderer_it =
       renderers_.find(renderer_process_id);
   if (renderer_it == renderers_.end() || renderer_it->second.empty())
     return;
   HashCollection& renderer_hashes = renderer_it->second;
   HashCollection remaining_hashes(remaining_markers.begin(),
                                   remaining_markers.end());
-  std::vector<uint32> removed_hashes;
-  std::set_difference(renderer_hashes.begin(),
-                      renderer_hashes.end(),
-                      remaining_hashes.begin(),
-                      remaining_hashes.end(),
-                      std::back_inserter(removed_hashes));
+  std::vector<uint32> removed_hashes =
+      base::STLSetDifference<std::vector<uint32> >(renderer_hashes,
+                                                   remaining_hashes);
   for (std::vector<uint32>::const_iterator hash_it = removed_hashes.begin();
        hash_it != removed_hashes.end();
        ++hash_it) {
     HashMisspellingMap::iterator misspelling_it = misspellings_.find(*hash_it);
     if (misspelling_it != misspellings_.end() &&
         !misspelling_it->second.action.IsFinal()) {
       misspelling_it->second.action.Finalize();
     }
   }
 }
@@ skipping 114 matching lines @@
   renderers_.clear();
 }
 
 const std::set<uint32>& Feedback::FindMisspellings(
     const string16& misspelled_text) const {
   const TextHashesMap::const_iterator text_it = text_.find(misspelled_text);
   return text_it == text_.end() ? empty_hash_collection_ : text_it->second;
 }
 
 }  // namespace spellcheck