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 <vector>
 
 #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 {
 
+// Global bool to ensure we only update the parameters from variations once.
+bool gUpdatedFromVariations = false;
+
+// Keys used in the variations params.
+const char kEngagementParams[] = "SiteEngagementParams";

[benwells, 2015/10/06 02:55:50]

Nit: can we just call this SiteEngagement?

[dominickn, 2015/10/06 05:00:39]

Done.

+const char kMaxPointsPerDayParam[] = "max_points_per_day";
+const char kNavigationPointsParam[] = "navigation_points";
+const char kUserInputPointsParam[] = "user_input_points";
+const char kDecayPeriodInDaysParam[] = "decay_period_in_days";
+const char kDecayPointsParam[] = "decay_points";
+
 // 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;
 
 // 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 24 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;
+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() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableSiteEngagementService);
 }
 
 SiteEngagementService::SiteEngagementService(Profile* profile)
     : SiteEngagementService(profile, make_scoped_ptr(new base::DefaultClock)) {
   content::BrowserThread::PostAfterStartupTask(
       FROM_HERE, content::BrowserThread::GetMessageLoopProxyForThread(
                      content::BrowserThread::UI),
       base::Bind(&SiteEngagementService::AfterStartupTask,
                  weak_factory_.GetWeakPtr()));
+
+  if (!gUpdatedFromVariations) {
+    SiteEngagementScore::UpdateFromVariations();
+    gUpdatedFromVariations = true;
+  }
 }
 
 SiteEngagementService::~SiteEngagementService() {
 }
 
 void SiteEngagementService::HandleNavigation(const GURL& url,
                                              ui::PageTransition transition) {
   SiteEngagementMetrics::RecordEngagement(
       SiteEngagementMetrics::ENGAGEMENT_NAVIGATION);
-  AddPoints(url, SiteEngagementScore::kNavigationPoints);
+  AddPoints(url, SiteEngagementScore::gNavigationPoints);
   RecordMetrics();
 }
 
 void SiteEngagementService::HandleUserInput(
     const GURL& url,
     SiteEngagementMetrics::EngagementType type) {
   SiteEngagementMetrics::RecordEngagement(type);
-  AddPoints(url, SiteEngagementScore::kUserInputPoints);
+  AddPoints(url, SiteEngagementScore::gUserInputPoints);
   RecordMetrics();
 }
 
 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_.get(), *score_dict);
 
@@ skipping 163 matching lines @@
 int SiteEngagementService::OriginsWithMaxEngagement(
     std::map<GURL, double>& score_map) {
   int total_origins = 0;
 
   for (const auto& value : score_map)
     if (value.second == SiteEngagementScore::kMaxPoints)
       ++total_origins;
 
   return total_origins;
 }