Minor refactor to support experiments in AppListMixer.

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>
 #include <vector>
 
 #include "ui/app_list/search_provider.h"
 #include "ui/app_list/search_result.h"
 
 namespace app_list {
 
 namespace {
 
 // Maximum number of results to show.
 const size_t kMaxResults = 6;
 
-// A value to indicate no max number of results limit.
-const size_t kNoMaxResultsLimit = 0;
-
 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(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 fox mixing their results.
+// Used to group relevant providers together for mixing their results.
 class Mixer::Group {
  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();
@@ skipping 32 matching lines @@
 
         // 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 + 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_; }
 
+  size_t max_results() const { return max_results_; }
+
  private:
   typedef std::vector<SearchProvider*> Providers;
   const size_t max_results_;
   const double boost_;
 
   Providers providers_;  // Not owned.
   SortedResults results_;
 
   DISALLOW_COPY_AND_ASSIGN(Group);
 };
@@ skipping 22 matching lines @@
   groups_[group_id]->AddProvider(provider);
 }
 
 void Mixer::MixAndPublish(bool is_voice_query,
                           const KnownResults& known_results) {
   FetchResults(is_voice_query, known_results);
 
   SortedResults results;
   results.reserve(kMaxResults);
 
-  // Add results from non-omnibox groups first.
+  // Add results from non-omnibox groups first. Limit to the maximum number of
+  // results in each group.
   for (size_t i = 0; i < groups_.size(); ++i) {
     if (!has_omnibox_group_ || i != omnibox_group_) {
       const Group& group = *groups_[i];
+      size_t num_results =
+          std::min(group.results().size(), group.max_results());
       results.insert(results.end(), group.results().begin(),
-                     group.results().end());
+                     group.results().begin() + num_results);
     }
   }
 
   // Collapse duplicate apps from local and web store.
   RemoveDuplicates(&results);
 
   // Fill the remaining slots with omnibox results. Always add at least one
   // omnibox result (even if there are no more slots; if we over-fill the
   // vector, the web store and people results will be removed in a later step).
+  // Note: max_results() is ignored for the omnibox group.
   if (has_omnibox_group_) {
     CHECK_LT(omnibox_group_, groups_.size());
     const Group& omnibox_group = *groups_[omnibox_group_];
     const size_t omnibox_results = std::min(
         omnibox_group.results().size(),
         results.size() < kMaxResults ? kMaxResults - results.size() : 1);
     results.insert(results.end(), omnibox_group.results().begin(),
                    omnibox_group.results().begin() + omnibox_results);
   }
 
@@ skipping 73 matching lines @@
   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