Cheer up spell-checking code

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_t 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.
@@ skipping 17 matching lines @@
 Feedback::Feedback(size_t max_total_text_size)
     : max_total_text_size_(max_total_text_size), total_text_size_(0) {
   DCHECK_GE(max_total_text_size, 1024U);
 }
 
 Feedback::~Feedback() {}
 
 Misspelling* Feedback::GetMisspelling(uint32_t hash) {
   HashMisspellingMap::iterator misspelling_it = misspellings_.find(hash);
   if (misspelling_it == misspellings_.end())
-    return NULL;
+    return nullptr;
   return &misspelling_it->second;
 }
 
 void Feedback::FinalizeRemovedMisspellings(
     int renderer_process_id,
     const std::vector<uint32_t>& 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_t> removed_hashes =
-      base::STLSetDifference<std::vector<uint32_t>>(renderer_hashes,
-                                                    remaining_hashes);
-  for (std::vector<uint32_t>::const_iterator hash_it = removed_hashes.begin();
-       hash_it != removed_hashes.end(); ++hash_it) {
-    HashMisspellingMap::iterator misspelling_it = misspellings_.find(*hash_it);
+  std::vector<HashCollection::value_type> removed_hashes =
+      base::STLSetDifference<std::vector<HashCollection::value_type>>(
+          renderer_hashes, remaining_hashes);
+  for (auto hash : removed_hashes) {
+    HashMisspellingMap::iterator misspelling_it = misspellings_.find(hash);
     if (misspelling_it != misspellings_.end() &&
         !misspelling_it->second.action.IsFinal()) {
       misspelling_it->second.action.Finalize();
     }
   }
 }
 
 bool Feedback::RendererHasMisspellings(int renderer_process_id) const {
   RendererHashesMap::const_iterator renderer_it =
       renderers_.find(renderer_process_id);
@@ skipping 82 matching lines @@
   text_[GetMisspelledString(misspelling)].insert(misspelling.hash);
   renderers_[renderer_process_id].insert(misspelling.hash);
 }
 
 bool Feedback::Empty() const {
   return misspellings_.empty();
 }
 
 std::vector<int> Feedback::GetRendersWithMisspellings() const {
   std::vector<int> renderers_with_misspellings;
-  for (RendererHashesMap::const_iterator renderer_it = renderers_.begin();
-       renderer_it != renderers_.end(); ++renderer_it) {
-    if (!renderer_it->second.empty())
-      renderers_with_misspellings.push_back(renderer_it->first);
+  for (const auto& renderer : renderers_) {
+    if (!renderer.second.empty())
+      renderers_with_misspellings.push_back(renderer.first);
   }
   return renderers_with_misspellings;
 }
 
 void Feedback::FinalizeAllMisspellings() {
-  for (HashMisspellingMap::iterator misspelling_it = misspellings_.begin();
-       misspelling_it != misspellings_.end(); ++misspelling_it) {
-    if (!misspelling_it->second.action.IsFinal())
-      misspelling_it->second.action.Finalize();
+  for (auto& misspelling : misspellings_) {
+    if (!misspelling.second.action.IsFinal())
+      misspelling.second.action.Finalize();
   }
 }
 
 std::vector<Misspelling> Feedback::GetAllMisspellings() const {
   std::vector<Misspelling> all_misspellings;
-  for (HashMisspellingMap::const_iterator misspelling_it =
-           misspellings_.begin();
-       misspelling_it != misspellings_.end(); ++misspelling_it) {
-    all_misspellings.push_back(misspelling_it->second);
-  }
+  for (const auto& misspelling : misspellings_)
+    all_misspellings.push_back(misspelling.second);
   return all_misspellings;
 }
 
 void Feedback::Clear() {
   total_text_size_ = 0;
   misspellings_.clear();
   text_.clear();
   renderers_.clear();
 }
 
 const std::set<uint32_t>& Feedback::FindMisspellings(
     const base::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