Allow the site engagement service thresholds to be varied via field trial.

chrome/browser/engagement/site_engagement_service.cc

 // Copyright 2015 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/engagement/site_engagement_service.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/command_line.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/time/clock.h"
 #include "base/values.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/engagement/site_engagement_helper.h"
 #include "chrome/browser/engagement/site_engagement_metrics.h"
 #include "chrome/browser/engagement/site_engagement_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
+#include "components/variations/variations_associated_data.h"
 #include "url/gurl.h"
 
 namespace {
 
 // Delta within which to consider scores equal.
 const double kScoreDelta = 0.001;
 
 // Delta within which to consider internal time values equal. Internal time
 // values are in microseconds, so this delta comes out at one second.
 const double kTimeDelta = 1000000;
@@ skipping 20 matching lines @@
 
   return make_scoped_ptr(static_cast<base::DictionaryValue*>(value.release()));
 }
 
 }  // namespace
 
 const char* SiteEngagementScore::kRawScoreKey = "rawScore";
 const char* SiteEngagementScore::kPointsAddedTodayKey = "pointsAddedToday";
 const char* SiteEngagementScore::kLastEngagementTimeKey = "lastEngagementTime";
 
+const char* SiteEngagementScore::kEngagementParams = "SiteEngagementParams";
+const char* SiteEngagementScore::kMaxPointsPerDayParam = "max_points_per_day";
+const char* SiteEngagementScore::kNavigationPointsParam = "navigation_points";
+const char* SiteEngagementScore::kUserInputPointsParam = "user_input_points";
+const char* SiteEngagementScore::kDecayPeriodInDaysParam =
+    "decay_period_in_days";
+const char* SiteEngagementScore::kDecayPointsParam = "decay_points";
+
 const double SiteEngagementScore::kMaxPoints = 100;
-const double SiteEngagementScore::kMaxPointsPerDay = 5;
-const double SiteEngagementScore::kNavigationPoints = 0.5;
-const double SiteEngagementScore::kUserInputPoints = 0.05;
-const int SiteEngagementScore::kDecayPeriodInDays = 7;
-const double SiteEngagementScore::kDecayPoints = 5;
+double SiteEngagementScore::gMaxPointsPerDay = 5;
+double SiteEngagementScore::gNavigationPoints = 0.5;
+double SiteEngagementScore::gUserInputPoints = 0.05;
+int SiteEngagementScore::gDecayPeriodInDays = 7;
+double SiteEngagementScore::gDecayPoints = 5;
+
+// static
+void SiteEngagementScore::UpdateFromVariations() {

[benwells, 2015/09/29 00:40:31]

Should something be calling this?

[dominickn, 2015/09/29 00:52:30]

It will once calamity's clean up CL lands. Then I will rebase this CL on that,
calling UpdateFromVariations() in a common init method that will clean up dead
scores, update from variations, and log UMA.

[benwells, 2015/09/29 01:10:44]

OK. Functions overwriting global variables feel weird, so I'm interested in
seeing where this is called. Ideally it will just be called once.

I'll wait to see how it is called before reviewing...

+  std::string max_points_per_day_param = variations::GetVariationParamValue(
+      kEngagementParams, kMaxPointsPerDayParam);
+  std::string navigation_points_param = variations::GetVariationParamValue(
+      kEngagementParams, kNavigationPointsParam);
+  std::string user_input_points_param = variations::GetVariationParamValue(
+      kEngagementParams, kUserInputPointsParam);
+  std::string decay_period_in_days_param = variations::GetVariationParamValue(
+      kEngagementParams, kDecayPeriodInDaysParam);
+  std::string decay_points_param = variations::GetVariationParamValue(
+      kEngagementParams, kDecayPointsParam);
+
+  if (!max_points_per_day_param.empty() && !navigation_points_param.empty() &&
+      !user_input_points_param.empty() && !decay_period_in_days_param.empty() &&
+      !decay_points_param.empty()) {
+    double max_points_per_day = 0;
+    double navigation_points = 0;
+    double user_input_points = 0;
+    int decay_period_in_days = 0;
+    double decay_points = 0;
+
+    if (base::StringToDouble(max_points_per_day_param, &max_points_per_day) &&
+        base::StringToDouble(navigation_points_param, &navigation_points) &&
+        base::StringToDouble(user_input_points_param, &user_input_points) &&
+        base::StringToInt(decay_period_in_days_param, &decay_period_in_days) &&
+        base::StringToDouble(decay_points_param, &decay_points) &&
+        max_points_per_day >= navigation_points &&
+        max_points_per_day >= user_input_points && navigation_points >= 0 &&
+        user_input_points >= 0 && decay_period_in_days > 0 &&
+        decay_points >= 0) {
+      gMaxPointsPerDay = max_points_per_day;
+      gNavigationPoints = navigation_points;
+      gUserInputPoints = user_input_points;
+      gDecayPeriodInDays = decay_period_in_days;
+      gDecayPoints = decay_points;
+    }
+  }
+}
 
 SiteEngagementScore::SiteEngagementScore(
     base::Clock* clock,
     const base::DictionaryValue& score_dict)
     : SiteEngagementScore(clock) {
   score_dict.GetDouble(kRawScoreKey, &raw_score_);
   score_dict.GetDouble(kPointsAddedTodayKey, &points_added_today_);
   double internal_time;
   if (score_dict.GetDouble(kLastEngagementTimeKey, &internal_time))
     last_engagement_time_ = base::Time::FromInternalValue(internal_time);
@@ skipping 11 matching lines @@
   // since the last update.
   raw_score_ = DecayedScore();
 
   base::Time now = clock_->Now();
   if (!last_engagement_time_.is_null() &&
       now.LocalMidnight() != last_engagement_time_.LocalMidnight()) {
     points_added_today_ = 0;
   }
 
   double to_add =
-      std::min(kMaxPoints - raw_score_, kMaxPointsPerDay - points_added_today_);
+      std::min(kMaxPoints - raw_score_, gMaxPointsPerDay - points_added_today_);
   to_add = std::min(to_add, points);
 
   points_added_today_ += to_add;
   raw_score_ += to_add;
 
   last_engagement_time_ = now;
 }
 
 bool SiteEngagementScore::MaxPointsPerDayAdded() {
   if (!last_engagement_time_.is_null() &&
       clock_->Now().LocalMidnight() != last_engagement_time_.LocalMidnight()) {
     points_added_today_ = 0;
   }
 
-  return points_added_today_ == kMaxPointsPerDay;
+  return points_added_today_ == gMaxPointsPerDay;
 }
 
 bool SiteEngagementScore::UpdateScoreDict(base::DictionaryValue* score_dict) {
   double raw_score_orig = 0;
   double points_added_today_orig = 0;
   double last_engagement_time_internal_orig = 0;
 
   score_dict->GetDouble(kRawScoreKey, &raw_score_orig);
   score_dict->GetDouble(kPointsAddedTodayKey, &points_added_today_orig);
   score_dict->GetDouble(kLastEngagementTimeKey,
@@ skipping 25 matching lines @@
 
 double SiteEngagementScore::DecayedScore() const {
   // Note that users can change their clock, so from this system's perspective
   // time can go backwards. If that does happen and the system detects that the
   // current day is earlier than the last engagement, no decay (or growth) is
   // applied.
   int days_since_engagement = (clock_->Now() - last_engagement_time_).InDays();
   if (days_since_engagement < 0)
     return raw_score_;
 
-  int periods = days_since_engagement / kDecayPeriodInDays;
-  double decayed_score = raw_score_ - periods * kDecayPoints;
+  int periods = days_since_engagement / gDecayPeriodInDays;
+  double decayed_score = raw_score_ - periods * gDecayPoints;
   return std::max(0.0, decayed_score);
 }
 
 // static
 SiteEngagementService* SiteEngagementService::Get(Profile* profile) {
   return SiteEngagementServiceFactory::GetForProfile(profile);
 }
 
 // static
 bool SiteEngagementService::IsEnabled() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableSiteEngagementService);
 }
 
 SiteEngagementService::SiteEngagementService(Profile* profile)
     : profile_(profile) {
   RecordStartupUmaStats();
 }
 
 SiteEngagementService::~SiteEngagementService() {
 }
 
 void SiteEngagementService::HandleNavigation(const GURL& url,
                                              ui::PageTransition transition) {
-  AddPoints(url, SiteEngagementScore::kNavigationPoints);
+  AddPoints(url, SiteEngagementScore::gNavigationPoints);
 }
 
 void SiteEngagementService::HandleUserInput(const GURL& url) {
-  AddPoints(url, SiteEngagementScore::kUserInputPoints);
+  AddPoints(url, SiteEngagementScore::gUserInputPoints);
 }
 
 double SiteEngagementService::GetScore(const GURL& url) {
   HostContentSettingsMap* settings_map =
     HostContentSettingsMapFactory::GetForProfile(profile_);
   scoped_ptr<base::DictionaryValue> score_dict =
       GetScoreDictForOrigin(settings_map, url);
   SiteEngagementScore score(&clock_, *score_dict);
 
   return score.Score();
@@ skipping 100 matching lines @@
   std::map<GURL, double> score_map = GetScoreMap();
 
   double total_score = 0;
   for (const auto& value : score_map)
     total_score += value.second;
 
   SiteEngagementMetrics::RecordTotalOriginsEngaged(score_map.size());
   SiteEngagementMetrics::RecordTotalCumulativeSiteEngagement(total_score);
   SiteEngagementMetrics::RecordEngagementPerOrigin(score_map);
 }