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

chrome/browser/engagement/site_engagement_service_unittest.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 "base/command_line.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/simple_test_clock.h"
 #include "base/values.h"
 #include "chrome/browser/engagement/site_engagement_helper.h"
 #include "chrome/browser/engagement/site_engagement_metrics.h"
@@ skipping 73 matching lines @@
     EXPECT_TRUE(initial_score.UpdateScoreDict(score_dict));
     SiteEngagementScore updated_score(&test_clock_, *score_dict);
     VerifyScore(updated_score, 5, 10, different_day);
   }
 
   base::SimpleTestClock test_clock_;
   SiteEngagementScore score_;
 };
 
 // Accumulate score many times on the same day. Ensure each time the score goes
-// up by kNavigationPoints, but not more than kMaxPointsPerDay.
+// up by gNavigationPoints, but not more than gMaxPointsPerDay.
 TEST_F(SiteEngagementScoreTest, AccumulateOnSameDay) {
   base::Time reference_time = GetReferenceTime();
 
   test_clock_.SetNow(reference_time);
   for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i) {
-    score_.AddPoints(SiteEngagementScore::kNavigationPoints);
-    EXPECT_EQ(std::min(SiteEngagementScore::kMaxPointsPerDay,
-                       (i + 1) * SiteEngagementScore::kNavigationPoints),
+    score_.AddPoints(SiteEngagementScore::gNavigationPoints);
+    EXPECT_EQ(std::min(SiteEngagementScore::gMaxPointsPerDay,
+                       (i + 1) * SiteEngagementScore::gNavigationPoints),
               score_.Score());
   }
 
-  EXPECT_EQ(SiteEngagementScore::kMaxPointsPerDay, score_.Score());
+  EXPECT_EQ(SiteEngagementScore::gMaxPointsPerDay, score_.Score());
 }
 
 // Accumulate on the first day to max that day's engagement, then accumulate on
 // a different day.
 TEST_F(SiteEngagementScoreTest, AccumulateOnTwoDays) {
   base::Time reference_time = GetReferenceTime();
   base::Time later_date = reference_time + base::TimeDelta::FromDays(2);
 
   test_clock_.SetNow(reference_time);
   for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i)
-    score_.AddPoints(SiteEngagementScore::kNavigationPoints);
+    score_.AddPoints(SiteEngagementScore::gNavigationPoints);
 
-  EXPECT_EQ(SiteEngagementScore::kMaxPointsPerDay, score_.Score());
+  EXPECT_EQ(SiteEngagementScore::gMaxPointsPerDay, score_.Score());
 
   test_clock_.SetNow(later_date);
   for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i) {
-    score_.AddPoints(SiteEngagementScore::kNavigationPoints);
+    score_.AddPoints(SiteEngagementScore::gNavigationPoints);
     double day_score =
-        std::min(SiteEngagementScore::kMaxPointsPerDay,
-                 (i + 1) * SiteEngagementScore::kNavigationPoints);
-    EXPECT_EQ(day_score + SiteEngagementScore::kMaxPointsPerDay,
+        std::min(SiteEngagementScore::gMaxPointsPerDay,
+                 (i + 1) * SiteEngagementScore::gNavigationPoints);
+    EXPECT_EQ(day_score + SiteEngagementScore::gMaxPointsPerDay,
               score_.Score());
   }
 
-  EXPECT_EQ(2 * SiteEngagementScore::kMaxPointsPerDay, score_.Score());
+  EXPECT_EQ(2 * SiteEngagementScore::gMaxPointsPerDay, score_.Score());
 }
 
 // Accumulate score on many consecutive days and ensure the score doesn't exceed
 // the maximum allowed.
 TEST_F(SiteEngagementScoreTest, AccumulateALotOnManyDays) {
   base::Time current_day = GetReferenceTime();
 
   for (int i = 0; i < kMoreDaysThanNeededToMaxTotalEngagement; ++i) {
     current_day += base::TimeDelta::FromDays(1);
     test_clock_.SetNow(current_day);
     for (int j = 0; j < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++j)
-      score_.AddPoints(SiteEngagementScore::kNavigationPoints);
+      score_.AddPoints(SiteEngagementScore::gNavigationPoints);
 
     EXPECT_EQ(std::min(SiteEngagementScore::kMaxPoints,
-                       (i + 1) * SiteEngagementScore::kMaxPointsPerDay),
+                       (i + 1) * SiteEngagementScore::gMaxPointsPerDay),
               score_.Score());
   }
 
   EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.Score());
 }
 
 // Accumulate a little on many consecutive days and ensure the score doesn't
 // exceed the maximum allowed.
 TEST_F(SiteEngagementScoreTest, AccumulateALittleOnManyDays) {
   base::Time current_day = GetReferenceTime();
 
   for (int i = 0; i < kMoreAccumulationsThanNeededToMaxTotalEngagement; ++i) {
     current_day += base::TimeDelta::FromDays(1);
     test_clock_.SetNow(current_day);
 
     for (int j = 0; j < kLessAccumulationsThanNeededToMaxDailyEngagement; ++j)
-      score_.AddPoints(SiteEngagementScore::kNavigationPoints);
+      score_.AddPoints(SiteEngagementScore::gNavigationPoints);
 
     EXPECT_EQ(
         std::min(SiteEngagementScore::kMaxPoints,
                  (i + 1) * kLessAccumulationsThanNeededToMaxDailyEngagement *
-                     SiteEngagementScore::kNavigationPoints),
+                     SiteEngagementScore::gNavigationPoints),
         score_.Score());
   }
 
   EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.Score());
 }
 
 // Accumulate a bit, then check the score decays properly for a range of times.
 TEST_F(SiteEngagementScoreTest, ScoresDecayOverTime) {
   base::Time current_day = GetReferenceTime();
 
   // First max the score.
   for (int i = 0; i < kMoreDaysThanNeededToMaxTotalEngagement; ++i) {
     current_day += base::TimeDelta::FromDays(1);
     test_clock_.SetNow(current_day);
 
     for (int j = 0; j < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++j)
-      score_.AddPoints(SiteEngagementScore::kNavigationPoints);
+      score_.AddPoints(SiteEngagementScore::gNavigationPoints);
   }
 
   EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.Score());
 
   // The score should not have decayed before the first decay period has
   // elapsed.
   test_clock_.SetNow(
       current_day +
-      base::TimeDelta::FromDays(SiteEngagementScore::kDecayPeriodInDays - 1));
+      base::TimeDelta::FromDays(SiteEngagementScore::gDecayPeriodInDays - 1));
   EXPECT_EQ(SiteEngagementScore::kMaxPoints, score_.Score());
 
   // The score should have decayed by one chunk after one decay period has
   // elapsed.
   test_clock_.SetNow(
       current_day +
-      base::TimeDelta::FromDays(SiteEngagementScore::kDecayPeriodInDays));
-  EXPECT_EQ(SiteEngagementScore::kMaxPoints - SiteEngagementScore::kDecayPoints,
+      base::TimeDelta::FromDays(SiteEngagementScore::gDecayPeriodInDays));
+  EXPECT_EQ(SiteEngagementScore::kMaxPoints - SiteEngagementScore::gDecayPoints,
             score_.Score());
 
   // The score should have decayed by the right number of chunks after a few
   // decay periods have elapsed.
   test_clock_.SetNow(
       current_day +
       base::TimeDelta::FromDays(kLessPeriodsThanNeededToDecayMaxScore *
-                                SiteEngagementScore::kDecayPeriodInDays));
+                                SiteEngagementScore::gDecayPeriodInDays));
   EXPECT_EQ(SiteEngagementScore::kMaxPoints -
                 kLessPeriodsThanNeededToDecayMaxScore *
-                    SiteEngagementScore::kDecayPoints,
+                    SiteEngagementScore::gDecayPoints,
             score_.Score());
 
   // The score should not decay below zero.
   test_clock_.SetNow(
       current_day +
       base::TimeDelta::FromDays(kMorePeriodsThanNeededToDecayMaxScore *
-                                SiteEngagementScore::kDecayPeriodInDays));
+                                SiteEngagementScore::gDecayPeriodInDays));
   EXPECT_EQ(0, score_.Score());
 }
 
 // Test that any expected decays are applied before adding points.
 TEST_F(SiteEngagementScoreTest, DecaysAppliedBeforeAdd) {
   base::Time current_day = GetReferenceTime();
 
   // Get the score up to something that can handle a bit of decay before
   for (int i = 0; i < kLessDaysThanNeededToMaxTotalEngagement; ++i) {
     current_day += base::TimeDelta::FromDays(1);
     test_clock_.SetNow(current_day);
 
     for (int j = 0; j < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++j)
-      score_.AddPoints(SiteEngagementScore::kNavigationPoints);
+      score_.AddPoints(SiteEngagementScore::gNavigationPoints);
   }
 
   double initial_score = kLessDaysThanNeededToMaxTotalEngagement *
-                         SiteEngagementScore::kMaxPointsPerDay;
+                         SiteEngagementScore::gMaxPointsPerDay;
   EXPECT_EQ(initial_score, score_.Score());
 
   // Go forward a few decay periods.
   test_clock_.SetNow(
       current_day +
       base::TimeDelta::FromDays(kLessPeriodsThanNeededToDecayMaxScore *
-                                SiteEngagementScore::kDecayPeriodInDays));
+                                SiteEngagementScore::gDecayPeriodInDays));
 
   double decayed_score =
       initial_score -
-      kLessPeriodsThanNeededToDecayMaxScore * SiteEngagementScore::kDecayPoints;
+      kLessPeriodsThanNeededToDecayMaxScore * SiteEngagementScore::gDecayPoints;
   EXPECT_EQ(decayed_score, score_.Score());
 
   // Now add some points.
-  score_.AddPoints(SiteEngagementScore::kNavigationPoints);
-  EXPECT_EQ(decayed_score + SiteEngagementScore::kNavigationPoints,
+  score_.AddPoints(SiteEngagementScore::gNavigationPoints);
+  EXPECT_EQ(decayed_score + SiteEngagementScore::gNavigationPoints,
             score_.Score());
 }
 
 // Test that going back in time is handled properly.
 TEST_F(SiteEngagementScoreTest, GoBackInTime) {
   base::Time current_day = GetReferenceTime();
 
   test_clock_.SetNow(current_day);
   for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i)
-    score_.AddPoints(SiteEngagementScore::kNavigationPoints);
+    score_.AddPoints(SiteEngagementScore::gNavigationPoints);
 
-  EXPECT_EQ(SiteEngagementScore::kMaxPointsPerDay, score_.Score());
+  EXPECT_EQ(SiteEngagementScore::gMaxPointsPerDay, score_.Score());
 
   // Adding to the score on an earlier date should be treated like another day,
   // and should not cause any decay.
   test_clock_.SetNow(current_day - base::TimeDelta::FromDays(
                                        kMorePeriodsThanNeededToDecayMaxScore *
-                                       SiteEngagementScore::kDecayPoints));
+                                       SiteEngagementScore::gDecayPoints));
   for (int i = 0; i < kMoreAccumulationsThanNeededToMaxDailyEngagement; ++i) {
-    score_.AddPoints(SiteEngagementScore::kNavigationPoints);
+    score_.AddPoints(SiteEngagementScore::gNavigationPoints);
     double day_score =
-        std::min(SiteEngagementScore::kMaxPointsPerDay,
-                 (i + 1) * SiteEngagementScore::kNavigationPoints);
-    EXPECT_EQ(day_score + SiteEngagementScore::kMaxPointsPerDay,
+        std::min(SiteEngagementScore::gMaxPointsPerDay,
+                 (i + 1) * SiteEngagementScore::gNavigationPoints);
+    EXPECT_EQ(day_score + SiteEngagementScore::gMaxPointsPerDay,
               score_.Score());
   }
 
-  EXPECT_EQ(2 * SiteEngagementScore::kMaxPointsPerDay, score_.Score());
+  EXPECT_EQ(2 * SiteEngagementScore::gMaxPointsPerDay, score_.Score());
 }
 
 // Test that scores are read / written correctly from / to empty score
 // dictionaries.
 TEST_F(SiteEngagementScoreTest, EmptyDictionary) {
   base::DictionaryValue dict;
   TestScoreInitializesAndUpdates(&dict, 0, 0, base::Time());
 }
 
 // Test that scores are read / written correctly from / to partially empty
@@ skipping 302 matching lines @@
 
   service->AddPoints(url1, 5.0);
   EXPECT_EQ(10.0, service->GetScore(url1));
 
   {
     // Decay one origin to zero by advancing time and expect the engagement
     // score to be cleaned up. The other score was changed a day later so it
     // will not have decayed at all.
     clock->SetNow(
         GetReferenceTime() +
-        base::TimeDelta::FromDays(SiteEngagementScore::kDecayPeriodInDays));
+        base::TimeDelta::FromDays(SiteEngagementScore::gDecayPeriodInDays));
 
     std::map<GURL, double> score_map = service->GetScoreMap();
     EXPECT_EQ(2u, score_map.size());
     EXPECT_EQ(10, score_map[url1]);
     EXPECT_EQ(0, score_map[url2]);
 
     service->CleanupEngagementScores();
 
     score_map = service->GetScoreMap();
     EXPECT_EQ(1u, score_map.size());
     EXPECT_EQ(10, score_map[url1]);
     EXPECT_EQ(0, service->GetScore(url2));
   }
 
   {
     // Decay the other origin to zero by advancing time and expect the
     // engagement score to be cleaned up.
     clock->SetNow(
         GetReferenceTime() +
-        base::TimeDelta::FromDays(3 * SiteEngagementScore::kDecayPeriodInDays));
+        base::TimeDelta::FromDays(3 * SiteEngagementScore::gDecayPeriodInDays));
 
     std::map<GURL, double> score_map = service->GetScoreMap();
     EXPECT_EQ(1u, score_map.size());
     EXPECT_EQ(0, score_map[url1]);
 
     service->CleanupEngagementScores();
 
     score_map = service->GetScoreMap();
     EXPECT_EQ(0u, score_map.size());
     EXPECT_EQ(0, service->GetScore(url1));
   }
 }