app_list::Mixer: Use range-based for loops internally.

ui/app_list/search/mixer.cc

 // Copyright 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.
 
 #include "ui/app_list/search/mixer.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <string>
@@ skipping 42 matching lines @@
  public:
   Group(size_t max_results, double boost)
       : max_results_(max_results), boost_(boost) {}
   ~Group() {}
 
   void AddProvider(SearchProvider* provider) { providers_.push_back(provider); }
 
   void FetchResults(bool is_voice_query, const KnownResults& known_results) {
     results_.clear();
 
-    for (Providers::const_iterator provider_it = providers_.begin();
-         provider_it != providers_.end();
-         ++provider_it) {
-      for (SearchProvider::Results::const_iterator result_it =
-               (*provider_it)->results().begin();
-           result_it != (*provider_it)->results().end();
-           ++result_it) {
-        DCHECK_GE((*result_it)->relevance(), 0.0);
-        DCHECK_LE((*result_it)->relevance(), 1.0);
-        DCHECK(!(*result_it)->id().empty());
+    for (const SearchProvider* provider : providers_) {
+      for (SearchResult* result : provider->results()) {

[calamity, 2015/02/09 03:47:59]

const SearchResult*?

[Matt Giuca, 2015/02/09 04:03:38]

No, because |result| gets put into a SortData at the end of this loop body, and
that requires a mutable SearchResult.

(For largely superficial reasons... actually I tried changing it to const and
only one test was relying on it being mutable, but it is too big of a change to
make just for this const.)

+        DCHECK_GE(result->relevance(), 0.0);
+        DCHECK_LE(result->relevance(), 1.0);
+        DCHECK(!result->id().empty());
 
         double boost = boost_;
         KnownResults::const_iterator known_it =
-            known_results.find((*result_it)->id());
+            known_results.find(result->id());
         if (known_it != known_results.end()) {
           switch (known_it->second) {
             case PERFECT_PRIMARY:
               boost = 4.0;
               break;
             case PREFIX_PRIMARY:
               boost = 3.75;
               break;
             case PERFECT_SECONDARY:
               boost = 3.25;
               break;
             case PREFIX_SECONDARY:
               boost = 3.0;
               break;
             case UNKNOWN_RESULT:
               NOTREACHED() << "Unknown result in KnownResults?";
               break;
           }
         }
 
         // If this is a voice query, voice results receive a massive boost.
-        if (is_voice_query && (*result_it)->voice_result())
+        if (is_voice_query && result->voice_result())
           boost += 4.0;
 
-        results_.push_back(
-            SortData(*result_it, (*result_it)->relevance() + boost));
+        results_.push_back(SortData(result, result->relevance() + boost));
       }
     }
 
     std::sort(results_.begin(), results_.end());
     if (max_results_ != kNoMaxResultsLimit && results_.size() > max_results_)
       results_.resize(max_results_);
   }
 
   const SortedResults& results() const { return results_; }
 
@@ skipping 85 matching lines @@
   IdToResultMap ui_results_map;
   for (size_t i = 0; i < ui_results->item_count(); ++i) {
     SearchResult* ui_result = ui_results->GetItemAt(i);
     ui_results_map[ui_result->id()] = ui_result;
   }
   // We have to erase all results at once so that observers are notified with
   // meaningful indexes.
   ui_results->RemoveAll();
 
   // Add items back to |ui_results| in the order of |new_results|.
-  for (size_t i = 0; i < new_results.size(); ++i) {
-    const SearchResult& new_result = *new_results[i].result;
+  for (const SortData& new_result_sortdata : new_results) {

[calamity, 2015/02/09 03:47:59]

I would prefer sort_data.

[Matt Giuca, 2015/02/09 04:03:38]

Done.

+    const SearchResult& new_result = *new_result_sortdata.result;
     IdToResultMap::const_iterator ui_result_it =
         ui_results_map.find(new_result.id());
     if (ui_result_it != ui_results_map.end()) {
       // Update and use the old result if it exists.
       SearchResult* ui_result = ui_result_it->second;
       UpdateResult(new_result, ui_result);
 
       // |ui_results| takes back ownership from |ui_results_map| here.
       ui_results->Add(ui_result);
 
       // Remove the item from the map so that it ends up only with unused
       // results.
       ui_results_map.erase(ui_result->id());
     } else {
       // Copy the result from |new_results| otherwise.
       ui_results->Add(new_result.Duplicate().release());
     }
   }
 
   // Delete the results remaining in the map as they are not in the new results.
-  for (IdToResultMap::const_iterator ui_result_it = ui_results_map.begin();
-       ui_result_it != ui_results_map.end();
-       ++ui_result_it) {
-    delete ui_result_it->second;
+  for (const auto& ui_result : ui_results_map) {
+    delete ui_result.second;
   }
 }
 
 void Mixer::RemoveDuplicates(SortedResults* results) {
   SortedResults final;
   final.reserve(results->size());
 
   std::set<std::string> id_set;
-  for (SortedResults::iterator it = results->begin(); it != results->end();
-       ++it) {
-    const std::string& id = it->result->id();
+  for (const SortData& result_sortdata : *results) {

[calamity, 2015/02/09 03:47:59]

Here too.

[Matt Giuca, 2015/02/09 04:03:38]

Done.

+    const std::string& id = result_sortdata.result->id();
     if (id_set.find(id) != id_set.end())
       continue;
 
     id_set.insert(id);
-    final.push_back(*it);
+    final.push_back(result_sortdata);
   }
 
   results->swap(final);
 }
 
 void Mixer::FetchResults(bool is_voice_query,
                          const KnownResults& known_results) {
   for (const auto& item : groups_)
     item.second->FetchResults(is_voice_query, known_results);
 }
 
 }  // namespace app_list