AppList Performance Optimization 2

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 10 matching lines @@
 void UpdateResult(const SearchResult& source, SearchResult* target) {
   target->set_display_type(source.display_type());
   target->set_title(source.title());
   target->set_title_tags(source.title_tags());
   target->set_details(source.details());
   target->set_details_tags(source.details_tags());
 }
 
 }  // namespace
 
-Mixer::SortData::SortData() : result(NULL), score(0.0) {
-}
+Mixer::SortData::SortData() : result(nullptr), score(0.0) {}
 
 Mixer::SortData::SortData(SearchResult* result, double score)
     : result(result), score(score) {
 }
 
 bool Mixer::SortData::operator<(const SortData& other) const {
   // This data precedes (less than) |other| if it has higher score.
   return score > other.score;
 }
 
 // Used to group relevant providers together for mixing their results.
 class Mixer::Group {
  public:
   Group(size_t max_results, double multiplier)
       : max_results_(max_results), multiplier_(multiplier) {}
   ~Group() {}
 
-  void AddProvider(SearchProvider* provider) { providers_.push_back(provider); }
+  void AddProvider(SearchProvider* provider) {
+    providers_.emplace_back(provider);
+  }
 
   void FetchResults(bool is_voice_query, const KnownResults& known_results) {
     results_.clear();
 
     for (const SearchProvider* provider : providers_) {
-      for (SearchResult* result : provider->results()) {
+      for (const auto& result : provider->results()) {
         DCHECK(!result->id().empty());
 
         // We cannot rely on providers to give relevance scores in the range
         // [0.0, 1.0] (e.g., PeopleProvider directly gives values from the
         // Google+ API). Clamp to that range.
-        double relevance = std::min(std::max(result->relevance(), 0.0), 1.0);
-
-        double multiplier = multiplier_;
+        const double relevance =
+            std::min(std::max(result->relevance(), 0.0), 1.0);
         double boost = 0.0;
 
         // Recommendations should not be affected by query-to-launch correlation
         // from KnownResults as it causes recommendations to become dominated by
         // previously clicked results. This happens because the recommendation
         // query is the empty string and the clicked results get forever
         // boosted.
         if (result->display_type() != SearchResult::DISPLAY_RECOMMENDATION) {
           KnownResults::const_iterator known_it =
               known_results.find(result->id());
@@ skipping 15 matching lines @@
                 NOTREACHED() << "Unknown result in KnownResults?";
                 break;
             }
           }
 
           // If this is a voice query, voice results receive a massive boost.
           if (is_voice_query && result->voice_result())
             boost += 4.0;
         }
 
-        results_.push_back(SortData(result, relevance * multiplier + boost));
+        results_.emplace_back(result.get(), relevance * multiplier_ + boost);
       }
     }
 
     std::sort(results_.begin(), results_.end());
   }
 
   const SortedResults& results() const { return results_; }
 
   size_t max_results() const { return max_results_; }
 
@@ skipping 27 matching lines @@
                           const KnownResults& known_results,
                           size_t num_max_results) {
   FetchResults(is_voice_query, known_results);
 
   SortedResults results;
   results.reserve(num_max_results);
 
   // Add results from each group. Limit to the maximum number of results in each
   // group.
   for (const Group* group : groups_) {
-    size_t num_results =
+    const size_t num_results =
         std::min(group->results().size(), group->max_results());
     results.insert(results.end(), group->results().begin(),
                    group->results().begin() + num_results);
   }
   // Remove results with duplicate IDs before sorting. If two providers give a
   // result with the same ID, the result from the provider with the *lower group
   // number* will be kept (e.g., an app result takes priority over a web store
   // result with the same ID).
   RemoveDuplicates(&results);
   std::sort(results.begin(), results.end());
 
-  if (results.size() < num_max_results) {
-    size_t original_size = results.size();
+  const size_t original_size = results.size();
+  if (original_size < num_max_results) {
     // We didn't get enough results. Insert all the results again, and this
     // time, do not limit the maximum number of results from each group. (This
     // will result in duplicates, which will be removed by RemoveDuplicates.)
     for (const Group* group : groups_) {
       results.insert(results.end(), group->results().begin(),
                      group->results().end());
     }
     RemoveDuplicates(&results);
     // Sort just the newly added results. This ensures that, for example, if
     // there are 6 Omnibox results (score = 0.8) and 1 People result (score =
@@ skipping 13 matching lines @@
   // to item.
   // 2. Use the order of items in |new_results| to build an ordered list. If the
   // result IDs exist in the map, update and use the item in the map and delete
   // it from the map afterwards. Otherwise, clone new items from |new_results|.
   // 3. Delete the objects remaining in the map as they are unused.
 
   // We have to erase all results at once so that observers are notified with
   // meaningful indexes.
   auto current_results = ui_results->RemoveAll();
   std::map<std::string, std::unique_ptr<SearchResult>> ui_results_map;
-  for (std::unique_ptr<SearchResult>& ui_result : current_results)
+  for (auto& ui_result : current_results)
     ui_results_map[ui_result->id()] = std::move(ui_result);
 
   // Add items back to |ui_results| in the order of |new_results|.
   for (const SortData& sort_data : new_results) {
     const SearchResult& new_result = *sort_data.result;
     auto 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.
       std::unique_ptr<SearchResult> ui_result = std::move(ui_result_it->second);
       UpdateResult(new_result, ui_result.get());
@@ skipping 14 matching lines @@
 
   // Any remaining results in |ui_results_map| will be automatically deleted.
 }
 
 void Mixer::RemoveDuplicates(SortedResults* results) {
   SortedResults final;
   final.reserve(results->size());
 
   std::set<std::string> id_set;
   for (const SortData& sort_data : *results) {
-    const std::string& id = sort_data.result->id();
-    if (id_set.find(id) != id_set.end())
+    if (!id_set.insert(sort_data.result->id()).second)
       continue;
 
-    id_set.insert(id);
-    final.push_back(sort_data);
+    final.emplace_back(sort_data);
   }
 
   results->swap(final);
 }
 
 void Mixer::FetchResults(bool is_voice_query,
                          const KnownResults& known_results) {
   for (auto* group : groups_)
     group->FetchResults(is_voice_query, known_results);
 }
 
 }  // namespace app_list