Don't demote top match for certain match types.

chrome/browser/omnibox/omnibox_field_trial.cc

 // Copyright (c) 2012 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 "chrome/browser/omnibox/omnibox_field_trial.h"
 
 #include <string>
 
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 236 matching lines @@
   // The value of the DemoteByType rule is a comma-separated list of
   // {ResultType + ":" + Number} where ResultType is an AutocompleteMatchType::
   // Type enum represented as an integer and Number is an integer number
   // between 0 and 100 inclusive.   Relevance scores of matches of that result
   // type are multiplied by Number / 100.  100 means no change.
   base::StringPairs kv_pairs;
   if (base::SplitStringIntoKeyValuePairs(demotion_rule, ':', ',', &kv_pairs)) {
     for (base::StringPairs::const_iterator it = kv_pairs.begin();
          it != kv_pairs.end(); ++it) {
       // This is a best-effort conversion; we trust the hand-crafted parameters
-      // downloaded from the server to be perfect.  There's no need for handle
+      // downloaded from the server to be perfect.  There's no need to handle
       // errors smartly.
       int k, v;
       base::StringToInt(it->first, &k);
       base::StringToInt(it->second, &v);
       (*demotions_by_type)[static_cast<AutocompleteMatchType::Type>(k)] =
           static_cast<float>(v) / 100.0f;
     }
   }
 }
 
+OmniboxFieldTrial::UndemotableTopMatchTypes
+OmniboxFieldTrial::GetUndemotableTopTypes(
+    AutocompleteInput::PageClassification current_page_classification) {
+  UndemotableTopMatchTypes undemotable_types;
+  const std::string types_rule =
+      OmniboxFieldTrial::GetValueForRuleInContext(
+          kUndemotableTopTypeRule,
+          current_page_classification);
+  // The value of the UndemotableTopTypes rule is a comma-separated list of
+  // AutocompleteMatchType::Type enums represented as an integer. The
+  // DemoteByType rule does not apply to the top match if the type of the top
+  // match is in this list.
+  std::vector<std::string> types;
+  base::SplitString(types_rule, ',', &types);
+  for (std::vector<std::string>::const_iterator it = types.begin();
+       it != types.end(); ++it) {
+    // This is a best-effort conversion; we trust the hand-crafted parameters
+    // downloaded from the server to be perfect.  There's no need to handle
+    // errors smartly.
+    int t;
+    base::StringToInt(*it, &t);
+    undemotable_types.insert(static_cast<AutocompleteMatchType::Type>(t));
+  }
+  return undemotable_types;
+}
+
 bool OmniboxFieldTrial::ReorderForLegalDefaultMatch(
     AutocompleteInput::PageClassification current_page_classification) {
   return OmniboxFieldTrial::GetValueForRuleInContext(
       kReorderForLegalDefaultMatchRule, current_page_classification) ==
       kReorderForLegalDefaultMatchRuleEnabled;
 }
 
 const char OmniboxFieldTrial::kBundledExperimentFieldTrialName[] =
     "OmniboxBundledExperimentV1";
 const char OmniboxFieldTrial::kShortcutsScoringMaxRelevanceRule[] =
     "ShortcutsScoringMaxRelevance";
 const char OmniboxFieldTrial::kSearchHistoryRule[] = "SearchHistory";
 const char OmniboxFieldTrial::kDemoteByTypeRule[] = "DemoteByType";
+const char OmniboxFieldTrial::kUndemotableTopTypeRule[] = "UndemotableTopTypes";
 const char OmniboxFieldTrial::kReorderForLegalDefaultMatchRule[] =
     "ReorderForLegalDefaultMatch";
 const char OmniboxFieldTrial::kReorderForLegalDefaultMatchRuleEnabled[] =
     "ReorderForLegalDefaultMatch";
 
 // Background and implementation details:
 //
 // Each experiment group in any field trial can come with an optional set of
 // parameters (key-value pairs).  In the bundled omnibox experiment
 // (kBundledExperimentFieldTrialName), each experiment group comes with a
@@ skipping 47 matching lines @@
   if (it != params.end())
     return it->second;
   // Fall back to the global instant extended context.
   it = params.find(rule + ":" + page_classification_str + ":*");
   if (it != params.end())
     return it->second;
   // Look up rule in the global context.
   it = params.find(rule + ":*:*");
   return (it != params.end()) ? it->second : std::string();
 }