Move variations component code to variations namespace.

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 <cmath>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 236 matching lines @@
 base::TimeDelta OmniboxFieldTrial::StopTimerFieldTrialDuration() {
   int stop_timer_ms;
   if (base::StringToInt(
       base::FieldTrialList::FindFullName(kStopTimerFieldTrialName),
           &stop_timer_ms))
     return base::TimeDelta::FromMilliseconds(stop_timer_ms);
   return base::TimeDelta::FromMilliseconds(1500);
 }
 
 bool OmniboxFieldTrial::InZeroSuggestFieldTrial() {
-  if (chrome_variations::GetVariationParamValue(
+  if (variations::GetVariationParamValue(
           kBundledExperimentFieldTrialName, kZeroSuggestRule) == "true")
     return true;
-  if (chrome_variations::GetVariationParamValue(
+  if (variations::GetVariationParamValue(
           kBundledExperimentFieldTrialName, kZeroSuggestRule) == "false")
     return false;
 #if defined(OS_WIN) || defined(OS_CHROMEOS) || defined(OS_LINUX) || \
     (defined(OS_MACOSX) && !defined(OS_IOS))
   return true;
 #else
   return false;
 #endif
 }
 
 bool OmniboxFieldTrial::InZeroSuggestMostVisitedFieldTrial() {
-  return chrome_variations::GetVariationParamValue(
+  return variations::GetVariationParamValue(
       kBundledExperimentFieldTrialName,
       kZeroSuggestVariantRule) == "MostVisited";
 }
 
 bool OmniboxFieldTrial::InZeroSuggestAfterTypingFieldTrial() {
-  return chrome_variations::GetVariationParamValue(
+  return variations::GetVariationParamValue(
       kBundledExperimentFieldTrialName,
       kZeroSuggestVariantRule) == "AfterTyping";
 }
 
 bool OmniboxFieldTrial::InZeroSuggestPersonalizedFieldTrial() {
-  return chrome_variations::GetVariationParamValue(
+  return variations::GetVariationParamValue(
       kBundledExperimentFieldTrialName,
       kZeroSuggestVariantRule) == "Personalized";
 }
 
 bool OmniboxFieldTrial::ShortcutsScoringMaxRelevance(
     OmniboxEventProto::PageClassification current_page_classification,
     int* max_relevance) {
   // The value of the rule is a string that encodes an integer containing
   // the max relevance.
   const std::string& max_relevance_str =
@@ skipping 51 matching lines @@
           static_cast<float>(v) / 100.0f;
     }
   }
 }
 
 void OmniboxFieldTrial::GetExperimentalHUPScoringParams(
     HUPScoringParams* scoring_params) {
   scoring_params->experimental_scoring_enabled = false;
 
   VariationParams params;
-  if (!chrome_variations::GetVariationParams(kBundledExperimentFieldTrialName,
-                                             &params))
+  if (!variations::GetVariationParams(kBundledExperimentFieldTrialName,
+                                      &params))
     return;
 
   VariationParams::const_iterator it = params.find(kHUPNewScoringEnabledParam);
   if (it != params.end()) {
     int enabled = 0;
     if (base::StringToInt(it->second, &enabled))
       scoring_params->experimental_scoring_enabled = (enabled != 0);
   }
 
   InitializeScoreBuckets(params, kHUPNewScoringTypedCountRelevanceCapParam,
       kHUPNewScoringTypedCountHalfLifeTimeParam,
       kHUPNewScoringTypedCountScoreBucketsParam,
       &scoring_params->typed_count_buckets);
   InitializeScoreBuckets(params, kHUPNewScoringVisitedCountRelevanceCapParam,
       kHUPNewScoringVisitedCountHalfLifeTimeParam,
       kHUPNewScoringVisitedCountScoreBucketsParam,
       &scoring_params->visited_count_buckets);
 }
 
 int OmniboxFieldTrial::HQPBookmarkValue() {
-  std::string bookmark_value_str = chrome_variations::
-      GetVariationParamValue(kBundledExperimentFieldTrialName,
-                             kHQPBookmarkValueRule);
+  std::string bookmark_value_str =
+      variations::GetVariationParamValue(kBundledExperimentFieldTrialName,
+                                         kHQPBookmarkValueRule);
   if (bookmark_value_str.empty())
     return 10;
   // 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
   // errors smartly.
   int bookmark_value;
   base::StringToInt(bookmark_value_str, &bookmark_value);
   return bookmark_value;
 }
 
 bool OmniboxFieldTrial::HQPAllowMatchInTLDValue() {
-  return chrome_variations::GetVariationParamValue(
+  return variations::GetVariationParamValue(
       kBundledExperimentFieldTrialName,
       kHQPAllowMatchInTLDRule) == "true";
 }
 
 bool OmniboxFieldTrial::HQPAllowMatchInSchemeValue() {
-  return chrome_variations::GetVariationParamValue(
+  return variations::GetVariationParamValue(
       kBundledExperimentFieldTrialName,
       kHQPAllowMatchInSchemeRule) == "true";
 }
 
 bool OmniboxFieldTrial::BookmarksIndexURLsValue() {
-  return chrome_variations::GetVariationParamValue(
+  return variations::GetVariationParamValue(
       kBundledExperimentFieldTrialName,
       kBookmarksIndexURLsRule) == "true";
 }
 
 bool OmniboxFieldTrial::DisableInlining() {
-  return chrome_variations::GetVariationParamValue(
+  return variations::GetVariationParamValue(
       kBundledExperimentFieldTrialName,
       kDisableInliningRule) == "true";
 }
 
 bool OmniboxFieldTrial::EnableAnswersInSuggest() {
   const CommandLine* cl = CommandLine::ForCurrentProcess();
   if (cl->HasSwitch(switches::kDisableAnswersInSuggest))
     return false;
   if (cl->HasSwitch(switches::kEnableAnswersInSuggest))
     return true;
 
-  return chrome_variations::GetVariationParamValue(
+  return variations::GetVariationParamValue(
       kBundledExperimentFieldTrialName,
       kAnswersInSuggestRule) == "true";
 }
 
 bool OmniboxFieldTrial::AddUWYTMatchEvenIfPromotedURLs() {
-  return chrome_variations::GetVariationParamValue(
+  return variations::GetVariationParamValue(
       kBundledExperimentFieldTrialName,
       kAddUWYTMatchEvenIfPromotedURLsRule) == "true";
 }
 
 bool OmniboxFieldTrial::DisplayHintTextWhenPossible() {
-  return chrome_variations::GetVariationParamValue(
+  return variations::GetVariationParamValue(
       kBundledExperimentFieldTrialName,
       kDisplayHintTextWhenPossibleRule) == "true";
 }
 
 const char OmniboxFieldTrial::kBundledExperimentFieldTrialName[] =
     "OmniboxBundledExperimentV1";
 const char OmniboxFieldTrial::kShortcutsScoringMaxRelevanceRule[] =
     "ShortcutsScoringMaxRelevance";
 const char OmniboxFieldTrial::kSearchHistoryRule[] = "SearchHistory";
 const char OmniboxFieldTrial::kDemoteByTypeRule[] = "DemoteByType";
@@ skipping 57 matching lines @@
 //
 // In short, this function tries to find the value associated with key
 // |rule|:|page_classification|:|instant_extended|, failing that it looks up
 // |rule|:*:|instant_extended|, failing that it looks up
 // |rule|:|page_classification|:*, failing that it looks up |rule|:*:*,
 // and failing that it returns the empty string.
 std::string OmniboxFieldTrial::GetValueForRuleInContext(
     const std::string& rule,
     OmniboxEventProto::PageClassification page_classification) {
   VariationParams params;
-  if (!chrome_variations::GetVariationParams(kBundledExperimentFieldTrialName,
-                                             &params)) {
+  if (!variations::GetVariationParams(kBundledExperimentFieldTrialName,
+                                      &params)) {
     return std::string();
   }
   const std::string page_classification_str =
       base::IntToString(static_cast<int>(page_classification));
   const std::string instant_extended =
       chrome::IsInstantExtendedAPIEnabled() ? "1" : "0";
   // Look up rule in this exact context.
   VariationParams::const_iterator it = params.find(
       rule + ":" + page_classification_str + ":" + instant_extended);
   if (it != params.end())
     return it->second;
   // Fall back to the global page classification context.
   it = params.find(rule + ":*:" + instant_extended);
   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();
 }