Add generic functions for getting typed variation parameter values

components/ntp_snippets/user_classifier.cc

 // Copyright 2016 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 "components/ntp_snippets/user_classifier.h"
 
 #include <algorithm>
 #include <cfloat>
 #include <string>
 
@@ skipping 73 matching lines @@
                   arraysize(kMetricKeys) ==
                       static_cast<int>(UserClassifier::Metric::COUNT) &&
                   arraysize(kLastTimeKeys) ==
                       static_cast<int>(UserClassifier::Metric::COUNT) &&
                   arraysize(kInitialHoursBetweenEvents) ==
                       static_cast<int>(UserClassifier::Metric::COUNT) &&
                   arraysize(kInitialHoursBetweenEventsParams) ==
                       static_cast<int>(UserClassifier::Metric::COUNT),
               "Fill in info for all metrics.");
 
-double GetParamValue(const char* param_name, double default_value) {
-  std::string param_value_str = variations::GetVariationParamValueByFeature(
-      kArticleSuggestionsFeature, param_name);
-  double param_value = 0;
-  if (!base::StringToDouble(param_value_str, &param_value)) {
-    LOG_IF(WARNING, !param_value_str.empty())
-        << "Invalid variation parameter for " << param_name;
-    return default_value;
-  }
-  return param_value;
-}
-
 // Computes the discount rate.
 double GetDiscountRatePerHour() {
-  double discount_rate_per_day =
-      GetParamValue(kDiscountRatePerDayParam, kDiscountRatePerDay);
+  double discount_rate_per_day = variations::GetVariationParamByFeatureAsDouble(
+      kArticleSuggestionsFeature, kDiscountRatePerDayParam,
+      kDiscountRatePerDay);
   // Check for illegal values.
   if (discount_rate_per_day <= 0 || discount_rate_per_day >= 1) {
     DLOG(WARNING) << "Illegal value " << discount_rate_per_day
                   << " for the parameter " << kDiscountRatePerDayParam
                   << " (must be strictly between 0 and 1; the default "
                   << kDiscountRatePerDay << " is used, instead).";
     discount_rate_per_day = kDiscountRatePerDay;
   }
   // Compute discount_rate_per_hour such that
   //   discount_rate_per_day = 1 - e^{-discount_rate_per_hour * 24}.
   return std::log(1.0 / (1.0 - discount_rate_per_day)) / 24.0;
 }
 
 double GetInitialHoursBetweenEvents(UserClassifier::Metric metric) {
-  return GetParamValue(
+  return variations::GetVariationParamByFeatureAsDouble(
+      kArticleSuggestionsFeature,
       kInitialHoursBetweenEventsParams[static_cast<int>(metric)],
       kInitialHoursBetweenEvents[static_cast<int>(metric)]);
 }
 
 double GetMinHours() {
-  return GetParamValue(kMinHoursParam, kMinHours);
+  return variations::GetVariationParamByFeatureAsDouble(
+      kArticleSuggestionsFeature, kMinHoursParam, kMinHours);
 }
 
 double GetMaxHours() {
-  return GetParamValue(kMaxHoursParam, kMaxHours);
+  return variations::GetVariationParamByFeatureAsDouble(
+      kArticleSuggestionsFeature, kMaxHoursParam, kMaxHours);
 }
 
 // Returns the new value of the metric using its |old_value|, assuming
 // |hours_since_last_time| hours have passed since it was last discounted.
 double DiscountMetric(double old_value,
                       double hours_since_last_time,
                       double discount_rate_per_hour) {
   // Compute the new discounted average according to the formula
   //   avg_events := e^{-discount_rate_per_hour * hours_since} * avg_events
   return std::exp(-discount_rate_per_hour * hours_since_last_time) * old_value;
@@ skipping 43 matching lines @@
 }
 
 }  // namespace
 
 UserClassifier::UserClassifier(PrefService* pref_service)
     : pref_service_(pref_service),
       discount_rate_per_hour_(GetDiscountRatePerHour()),
       min_hours_(GetMinHours()),
       max_hours_(GetMaxHours()),
       active_consumer_scrolls_at_least_once_per_hours_(
-          GetParamValue(kActiveConsumerScrollsAtLeastOncePerHoursParam,
-                        kActiveConsumerScrollsAtLeastOncePerHours)),
+          variations::GetVariationParamByFeatureAsDouble(
+              kArticleSuggestionsFeature,
+              kActiveConsumerScrollsAtLeastOncePerHoursParam,
+              kActiveConsumerScrollsAtLeastOncePerHours)),
       rare_user_opens_ntp_at_most_once_per_hours_(
-          GetParamValue(kRareUserOpensNTPAtMostOncePerHoursParam,
-                        kRareUserOpensNTPAtMostOncePerHours)) {
+          variations::GetVariationParamByFeatureAsDouble(
+              kArticleSuggestionsFeature,
+              kRareUserOpensNTPAtMostOncePerHoursParam,
+              kRareUserOpensNTPAtMostOncePerHours)) {
   // The pref_service_ can be null in tests.
   if (!pref_service_) {
     return;
   }
 
   // TODO(jkrcal): Store the current discount rate per hour into prefs. If it
   // differs from the previous value, rescale the metric values so that the
   // expectation does not change abruptly!
 
   // Initialize the prefs storing the last time: the counter has just started!
@@ skipping 164 matching lines @@
 
 void UserClassifier::SetMetricValue(Metric metric, double metric_value) {
   pref_service_->SetDouble(kMetricKeys[static_cast<int>(metric)], metric_value);
 }
 
 void UserClassifier::ClearMetricValue(Metric metric) {
   pref_service_->ClearPref(kMetricKeys[static_cast<int>(metric)]);
 }
 
 }  // namespace ntp_snippets