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/time/default_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_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 "content/public/browser/browser_thread.h"
 #include "url/gurl.h"
 
 namespace {
 
 // Length of time between metrics logging.
 const base::TimeDelta metrics_interval = base::TimeDelta::FromMinutes(60);
 
 // Delta within which to consider scores equal.
 const double kScoreDelta = 0.001;
@@ skipping 29 matching lines @@
     return make_scoped_ptr(new base::DictionaryValue());
 
   if (!value->IsType(base::Value::TYPE_DICTIONARY))
     return make_scoped_ptr(new base::DictionaryValue());
 
   return make_scoped_ptr(static_cast<base::DictionaryValue*>(value.release()));
 }
 
 }  // namespace
 
+const double SiteEngagementScore::kMaxPoints = 100;
+double SiteEngagementScore::gMaxPointsPerDay = 5;
+double SiteEngagementScore::gNavigationPoints = 0.5;
+double SiteEngagementScore::gUserInputPoints = 0.05;
+int SiteEngagementScore::gDecayPeriodInDays = 7;
+double SiteEngagementScore::gDecayPoints = 5;
+
 const char* SiteEngagementScore::kRawScoreKey = "rawScore";
 const char* SiteEngagementScore::kPointsAddedTodayKey = "pointsAddedToday";
 const char* SiteEngagementScore::kLastEngagementTimeKey = "lastEngagementTime";
 
-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;
+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";
+
+// static
+void SiteEngagementScore::UpdateFromVariations() {
+  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()) {
     return false;
   }
 
-  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() {
@@ skipping 10 matching lines @@
                  weak_factory_.GetWeakPtr()));
 }
 
 SiteEngagementService::~SiteEngagementService() {
 }
 
 void SiteEngagementService::HandleNavigation(const GURL& url,
                                              ui::PageTransition transition) {
   SiteEngagementMetrics::RecordEngagement(
       SiteEngagementMetrics::ENGAGEMENT_NAVIGATION);
-  AddPoints(url, SiteEngagementScore::kNavigationPoints);
+  AddPoints(url, SiteEngagementScore::gNavigationPoints);
 
   if (clock_->Now() - last_metrics_time_ >= metrics_interval)
     RecordMetrics();
 }
 
 void SiteEngagementService::HandleUserInput(
     const GURL& url,
     SiteEngagementMetrics::EngagementType type) {
   SiteEngagementMetrics::RecordEngagement(type);
-  AddPoints(url, SiteEngagementScore::kUserInputPoints);
+  AddPoints(url, SiteEngagementScore::gUserInputPoints);
 
   if (clock_->Now() - last_metrics_time_ >= metrics_interval)
     RecordMetrics();
 }
 
 double SiteEngagementService::GetScore(const GURL& url) {
   HostContentSettingsMap* settings_map =
     HostContentSettingsMapFactory::GetForProfile(profile_);
   scoped_ptr<base::DictionaryValue> score_dict =
       GetScoreDictForOrigin(settings_map, url);
@@ skipping 52 matching lines @@
       return;
 
     settings_map->SetWebsiteSetting(pattern, ContentSettingsPattern::Wildcard(),
                                     CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT,
                                     std::string(), score_dict.release());
   }
 }
 
 void SiteEngagementService::AfterStartupTask() {
   CleanupEngagementScores();
+  SiteEngagementScore::UpdateFromVariations();

[benwells, 2015/10/02 01:37:42]

I think this is the wrong place for this, as there will be some delay between
the service being created and the startup task happening.

You should probably do it in the constructor instead.

I think it would also be good to ensure it only happens once, maybe with another
global variable. Doing it multiple times (i.e. for every profile) is probably ok
but it just feels like something waiting to go wrong. (yes I know the banner
stuff does it like this but that made me a bit uneasy too).

[dominickn, 2015/10/02 06:29:05]

Done.

   RecordMetrics();
 }
 
 void SiteEngagementService::CleanupEngagementScores() {
   HostContentSettingsMap* settings_map =
     HostContentSettingsMapFactory::GetForProfile(profile_);
   scoped_ptr<ContentSettingsForOneType> engagement_settings =
       GetEngagementContentSettings(settings_map);
 
   for (const auto& site : *engagement_settings) {
@@ skipping 66 matching lines @@
   SiteEngagementMetrics::RecordAverageEngagement(average_engagement);
   SiteEngagementMetrics::RecordEngagementScores(score_map);
 
   SiteEngagementMetrics::RecordOriginsWithMaxDailyEngagement(
       OriginsWithMaxDailyEngagement());
   SiteEngagementMetrics::RecordOriginsWithMaxEngagement(
       origins_with_max_engagement);
   SiteEngagementMetrics::RecordPercentOriginsWithMaxEngagement(
       percent_origins_with_max_engagement);
 }