[Merge to M53][Chrome OS] Change layout of the launcher.

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 "base/command_line.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "ui/app_list/app_list_switches.h"
 #include "ui/app_list/search_provider.h"
 #include "ui/app_list/search_result.h"
 
 namespace app_list {
 
 namespace {
 
-// Maximum number of results to show. Ignored if the AppListMixer field trial is
-// "Blended".
-const size_t kMaxResults = 6;
-
 // The minimum number of results to show, if the AppListMixer field trial is
 // "Blended". If this quota is not reached, the per-group limitations are
 // removed and we try again. (We may still not reach the minumum, but at least
 // we tried.) Ignored if the field trial is off.
 const size_t kMinBlendedResults = 6;
 
 const char kAppListMixerFieldTrialName[] = "AppListMixer";
 const char kAppListMixerFieldTrialEnabled[] = "Blended";
 const char kAppListMixerFieldTrialDisabled[] = "Control";
 
@@ skipping 156 matching lines @@
   omnibox_group_ = id;
   has_omnibox_group_ = true;
   return id;
 }
 
 void Mixer::AddProviderToGroup(size_t group_id, SearchProvider* provider) {
   groups_[group_id]->AddProvider(provider);
 }
 
 void Mixer::MixAndPublish(bool is_voice_query,
-                          const KnownResults& known_results) {
+                          const KnownResults& known_results,
+                          size_t num_max_results) {
   FetchResults(is_voice_query, known_results);
 
   SortedResults results;
 
   if (IsBlendedMixerTrialEnabled()) {
     results.reserve(kMinBlendedResults);
 
     // Add results from each group. Limit to the maximum number of results in
     // each group.
     for (const Group* group : groups_) {
@@ skipping 20 matching lines @@
       }
       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 =
       // 0.4) that the People result will be 5th, not 7th, because the Omnibox
       // group has a soft maximum of 4 results. (Otherwise, the People result
       // would not be seen at all once the result list is truncated.)
       std::sort(results.begin() + original_size, results.end());
     }
   } else {
-    results.reserve(kMaxResults);
+    results.reserve(num_max_results);
 
     // 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().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);
+          omnibox_group.results().size(), results.size() < num_max_results
+                                              ? num_max_results - results.size()
+                                              : 1);
       results.insert(results.end(), omnibox_group.results().begin(),
                      omnibox_group.results().begin() + omnibox_results);
     }
 
     std::sort(results.begin(), results.end());
     RemoveDuplicates(&results);
-    if (results.size() > kMaxResults)
-      results.resize(kMaxResults);
+    if (results.size() > num_max_results)
+      results.resize(num_max_results);
   }
 
   Publish(results, ui_results_);
 }
 
 void Mixer::Publish(const SortedResults& new_results,
                     AppListModel::SearchResults* ui_results) {
   typedef std::map<std::string, SearchResult*> IdToResultMap;
 
   // The following algorithm is used:
@@ skipping 60 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