Prevent site engagement scores from decaying when Chrome isn't in use.

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 "chrome/browser/engagement/site_engagement_service.h"
 
 #include <utility>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/simple_test_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_score.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/browser/content_settings_observer.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/history/core/browser/history_database_params.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/test/test_history_database.h"
+#include "components/prefs/pref_service.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/web_contents_tester.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 base::FilePath g_temp_history_dir;
 
 const int kMoreAccumulationsThanNeededToMaxDailyEngagement = 40;
 const int kMoreDaysThanNeededToMaxTotalEngagement = 40;
-const int kLessPeriodsThanNeededToDecayMaxScore = 2;
 const int kMorePeriodsThanNeededToDecayMaxScore = 40;
 
 // Waits until a change is observed in site engagement content settings.
 class SiteEngagementChangeWaiter : public content_settings::Observer {
  public:
   explicit SiteEngagementChangeWaiter(Profile* profile) : profile_(profile) {
     HostContentSettingsMapFactory::GetForProfile(profile)->AddObserver(this);
   }
   ~SiteEngagementChangeWaiter() override {
     HostContentSettingsMapFactory::GetForProfile(profile_)->RemoveObserver(
@@ skipping 606 matching lines @@
   for (const std::string& histogram_name : engagement_bucket_histogram_names)
     histograms.ExpectTotalCount(histogram_name, 3);
 
   histograms.ExpectBucketCount(engagement_bucket_histogram_names[0], 100, 1);
   histograms.ExpectBucketCount(engagement_bucket_histogram_names[0], 33, 1);
   histograms.ExpectBucketCount(engagement_bucket_histogram_names[0], 66, 1);
   histograms.ExpectBucketCount(engagement_bucket_histogram_names[1], 33, 1);
   histograms.ExpectBucketCount(engagement_bucket_histogram_names[1], 66, 1);
 }
 
-// Expect that sites that have reached zero engagement are cleaned up.
+// Expect that sites that have reached zero engagement are cleaned up. Expect
+// engagement times to be reset if too much time has passed since the last
+// engagement.
 TEST_F(SiteEngagementServiceTest, CleanupEngagementScores) {
   base::SimpleTestClock* clock = new base::SimpleTestClock();
   std::unique_ptr<SiteEngagementService> service(
       new SiteEngagementService(profile(), base::WrapUnique(clock)));
 
-  base::Time current_day = GetReferenceTime();
-  clock->SetNow(current_day);
+  // Set the base time to be (obsoletion period + 2 * (decay period - 1 second))
+  // in the past. The one second offset ensures that engagement won't decay
+  // (yet).
+  base::TimeDelta one_second = base::TimeDelta::FromSeconds(1);
+  base::TimeDelta obsoletion_period = base::TimeDelta::FromHours(
+      SiteEngagementScore::GetObsoleteLastEngagementPeriodInHours());
+  base::TimeDelta decay_period =
+      base::TimeDelta::FromDays(SiteEngagementScore::GetDecayPeriodInDays());
+  base::TimeDelta shorter_than_decay_period = decay_period - one_second;
+  base::Time base_time =
+      GetReferenceTime() - obsoletion_period - shorter_than_decay_period * 2;
+  clock->SetNow(base_time);
 
   // The https and http versions of www.google.com should be separate.
   GURL url1("https://www.google.com/");
   GURL url2("http://www.google.com/");
+  GURL url3("http://maps.google.com/");
+  GURL url4("http://drive.google.com/");
 
   EXPECT_EQ(0, service->GetScore(url1));
   EXPECT_EQ(0, service->GetScore(url2));
+  EXPECT_EQ(0, service->GetScore(url3));
+  EXPECT_EQ(0, service->GetScore(url4));
 
-  // Add the maximum number of points for one day.
+  // Add the maximum number of points for one day for two origins. Leave url2
+  // alone after this.
   service->AddPoints(url1, 5.0);
+  service->AddPoints(url2, 5.0);
   EXPECT_EQ(5.0, service->GetScore(url1));
-  service->AddPoints(url2, 5.0);
   EXPECT_EQ(5.0, service->GetScore(url2));
 
-  // Add more points by moving to another day.
-  clock->SetNow(GetReferenceTime() + base::TimeDelta::FromDays(1));
+  // Add more points by moving to another day. This is (obsoletion_period
+  // + shorter_than_decay_period) in the past.
+  base_time += shorter_than_decay_period;
+  clock->SetNow(base_time);
+  service->AddPoints(url1, 2.5);
+  service->AddPoints(url3, 5.0);
+  EXPECT_EQ(7.5, service->GetScore(url1));
+  EXPECT_EQ(5.0, service->GetScore(url3));
 
-  service->AddPoints(url1, 5.0);
+  // Add more points by moving to another day. This is obsoletion_period in
+  // the past.
+  base_time += shorter_than_decay_period;
+  clock->SetNow(base_time);
+  service->AddPoints(url1, 2.5);
+  service->AddPoints(url4, 5.0);
   EXPECT_EQ(10.0, service->GetScore(url1));
+  EXPECT_EQ(5.0, service->GetScore(url4));
 
   {
-    // 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());
+    ASSERT_TRUE(service->IsLastEngagementObsolete());
+
+    // Run a cleanup. Last engagement times will be reset relative to today.
+    // After the reset, url2 was last accessed > decay_period ago, so it will
+    // still decay. Everything else will be within a decay period and not decay.
+    service->CleanupEngagementScores(true);
+
+    std::map<GURL, double> score_map = service->GetScoreMap();
+    EXPECT_EQ(3u, score_map.size());
+    EXPECT_EQ(10, score_map[url1]);
+    EXPECT_EQ(5.0, score_map[url3]);
+    EXPECT_EQ(5.0, score_map[url4]);
+    EXPECT_EQ(0, service->GetScore(url2));
+
+    EXPECT_EQ(clock->Now(),
+              service->CreateEngagementScore(url1).last_engagement_time());
+    EXPECT_EQ(clock->Now() - shorter_than_decay_period,
+              service->CreateEngagementScore(url3).last_engagement_time());
+    EXPECT_EQ(clock->Now(),
+              service->CreateEngagementScore(url4).last_engagement_time());
+  }
+
+  {
+    // Advance time by a second and expect url3 to be decayed to zero. Run a
+    // cleanup without adjusting times and expect url3 to be purged.
+    clock->SetNow(GetReferenceTime() + one_second);
+    ASSERT_FALSE(service->IsLastEngagementObsolete());
+
+    std::map<GURL, double> score_map = service->GetScoreMap();
+    EXPECT_EQ(3u, score_map.size());
+    EXPECT_EQ(10, score_map[url1]);
+    EXPECT_EQ(0, score_map[url3]);
+    EXPECT_EQ(5.0, score_map[url4]);
+
+    service->CleanupEngagementScores(false);
+
+    score_map = service->GetScoreMap();
+    EXPECT_EQ(2u, score_map.size());
+    EXPECT_EQ(10, score_map[url1]);
+    EXPECT_EQ(5.0, score_map[url4]);
+    EXPECT_EQ(0, service->GetScore(url3));
+  }
+
+  {
+    // Decay the final two origins to zero and expect them to be cleaned up.
+    // This needs to be done in two calls or else the score will be obsolete.
     clock->SetNow(
         GetReferenceTime() +
-        base::TimeDelta::FromDays(SiteEngagementScore::GetDecayPeriodInDays()));
+        base::TimeDelta::FromDays(SiteEngagementScore::GetDecayPeriodInDays()) +
+        one_second);
+    ASSERT_FALSE(service->IsLastEngagementObsolete());
 
     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]);
+    EXPECT_EQ(5, score_map[url1]);
+    EXPECT_EQ(0, score_map[url4]);
 
-    service->CleanupEngagementScores();
+    service->CleanupEngagementScores(false);
 
     score_map = service->GetScoreMap();
     EXPECT_EQ(1u, score_map.size());
-    EXPECT_EQ(10, score_map[url1]);
-    EXPECT_EQ(0, service->GetScore(url2));
-  }
+    EXPECT_EQ(5, score_map[url1]);
+    EXPECT_EQ(0, service->GetScore(url4));
 
-  {
-    // 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::GetDecayPeriodInDays()));
+                  2 * base::TimeDelta::FromDays(
+                          SiteEngagementScore::GetDecayPeriodInDays()) +
+                  one_second);
+    ASSERT_FALSE(service->IsLastEngagementObsolete());
 
-    std::map<GURL, double> score_map = service->GetScoreMap();
+    score_map = service->GetScoreMap();
     EXPECT_EQ(1u, score_map.size());
     EXPECT_EQ(0, score_map[url1]);
 
-    service->CleanupEngagementScores();
+    service->CleanupEngagementScores(false);
 
     score_map = service->GetScoreMap();
     EXPECT_EQ(0u, score_map.size());
     EXPECT_EQ(0, service->GetScore(url1));
   }
 }
 
 TEST_F(SiteEngagementServiceTest, NavigationAccumulation) {
   GURL url("https://www.google.com/");
 
@@ skipping 316 matching lines @@
   // Trigger decay and histogram hit.
   service->AddPoints(origin1, 0.01);
   histograms.ExpectUniqueSample(
       SiteEngagementMetrics::kScoreDecayedFromHistogram,
       SiteEngagementScore::kMaxPoints, 1);
   histograms.ExpectUniqueSample(
       SiteEngagementMetrics::kScoreDecayedToHistogram,
       SiteEngagementScore::kMaxPoints - SiteEngagementScore::GetDecayPoints(),
       1);
 
-  // Check histograms after a few decay periods.
-  clock->SetNow(current_day + base::TimeDelta::FromDays(
-                                  kLessPeriodsThanNeededToDecayMaxScore *
-                                  SiteEngagementScore::GetDecayPeriodInDays()));
+  // Check histograms after another decay period.
+  clock->SetNow(current_day +
+                base::TimeDelta::FromDays(
+                    2 * SiteEngagementScore::GetDecayPeriodInDays()));
   // Trigger decay and histogram hit.
   service->AddPoints(origin1, 0.01);
   histograms.ExpectTotalCount(SiteEngagementMetrics::kScoreDecayedFromHistogram,
                               2);
   histograms.ExpectTotalCount(SiteEngagementMetrics::kScoreDecayedToHistogram,
                               2);
 
-  // Check decay to zero.
-  clock->SetNow(current_day + base::TimeDelta::FromDays(
-                                  kMorePeriodsThanNeededToDecayMaxScore *
-                                  SiteEngagementScore::GetDecayPeriodInDays()));
-  // Trigger decay and histogram hit.
-  service->AddPoints(origin1, 0.01);
+  // Check decay to zero. Start at the 3rd decay period (we have had two
+  // already). This will be 40 decays in total.
+  for (int i = 3; i <= kMorePeriodsThanNeededToDecayMaxScore; ++i) {
+    clock->SetNow(current_day +
+                  base::TimeDelta::FromDays(
+                      i * SiteEngagementScore::GetDecayPeriodInDays()));
+    // Trigger decay and histogram hit.
+    service->AddPoints(origin1, 0.01);
+  }
   histograms.ExpectTotalCount(SiteEngagementMetrics::kScoreDecayedFromHistogram,
-                              3);
+                              kMorePeriodsThanNeededToDecayMaxScore);
   histograms.ExpectTotalCount(SiteEngagementMetrics::kScoreDecayedToHistogram,
-                              3);
+                              kMorePeriodsThanNeededToDecayMaxScore);
+  // It should have taken (20 - 3) = 17 of the 38 decays to get to zero, since
+  // we started from 95. Expect the remaining 21 decays to be to bucket 0 (and
+  // hence 20 from bucket 0).
+  histograms.ExpectBucketCount(
+      SiteEngagementMetrics::kScoreDecayedFromHistogram, 0, 20);
   histograms.ExpectBucketCount(SiteEngagementMetrics::kScoreDecayedToHistogram,
-                               0, 1);
+                               0, 21);
   // Trigger decay and histogram hit for origin2, checking an independent decay.
   service->AddPoints(origin2, 0.01);
   histograms.ExpectTotalCount(SiteEngagementMetrics::kScoreDecayedFromHistogram,
-                              4);
+                              kMorePeriodsThanNeededToDecayMaxScore + 1);
   histograms.ExpectTotalCount(SiteEngagementMetrics::kScoreDecayedToHistogram,
-                              4);
+                              kMorePeriodsThanNeededToDecayMaxScore + 1);
   histograms.ExpectBucketCount(
-      SiteEngagementMetrics::kScoreDecayedFromHistogram, 0, 1);
+      SiteEngagementMetrics::kScoreDecayedFromHistogram, 0, 21);
   histograms.ExpectBucketCount(SiteEngagementMetrics::kScoreDecayedToHistogram,
-                               0, 2);
+                               0, 22);
 
   // Add more points and ensure no more samples are present.
   service->AddPoints(origin1, 0.01);
   service->AddPoints(origin2, 0.01);
   histograms.ExpectTotalCount(SiteEngagementMetrics::kScoreDecayedFromHistogram,
-                              4);
+                              kMorePeriodsThanNeededToDecayMaxScore + 1);
   histograms.ExpectTotalCount(SiteEngagementMetrics::kScoreDecayedToHistogram,
-                              4);
+                              kMorePeriodsThanNeededToDecayMaxScore + 1);
 }
+
+TEST_F(SiteEngagementServiceTest, PersistLastEngagementTime) {
+  // The last engagement time should start off null in prefs and in the service.
+  base::Time last_engagement_time = base::Time::FromInternalValue(
+      profile()->GetPrefs()->GetInt64(prefs::kSiteEngagementLastUpdateTime));
+
+  ASSERT_TRUE(last_engagement_time.is_null());
+
+  base::SimpleTestClock* clock = new base::SimpleTestClock();
+  std::unique_ptr<SiteEngagementService> service(
+      new SiteEngagementService(profile(), base::WrapUnique(clock)));
+
+  ASSERT_TRUE(service->last_engagement_time_.is_null());
+
+  base::Time current_day = GetReferenceTime();
+  clock->SetNow(current_day);
+
+  // Add points should set the last engagement time in the service, but not
+  // persist it to disk.
+  GURL origin("http://www.google.com/");
+  service->AddPoints(origin, 1);
+
+  last_engagement_time = base::Time::FromInternalValue(
+      profile()->GetPrefs()->GetInt64(prefs::kSiteEngagementLastUpdateTime));
+
+  ASSERT_TRUE(last_engagement_time.is_null());
+  ASSERT_FALSE(service->last_engagement_time_.is_null());
+  EXPECT_EQ(service->last_engagement_time_, current_day);
+
+  // Running a cleanup and updating last engagement times should persist the
+  // last engagement time to disk.
+  current_day +=
+      base::TimeDelta::FromHours(
+          SiteEngagementScore::GetObsoleteLastEngagementPeriodInHours());
+  clock->SetNow(current_day);
+  service->CleanupEngagementScores(true);
+
+  last_engagement_time = base::Time::FromInternalValue(
+      profile()->GetPrefs()->GetInt64(prefs::kSiteEngagementLastUpdateTime));
+
+  ASSERT_FALSE(last_engagement_time.is_null());
+  EXPECT_EQ(last_engagement_time, current_day);
+  EXPECT_EQ(service->last_engagement_time_, current_day);
+
+  // Add some more points and ensure the value isn't persisted.
+  base::Time later_in_day = current_day + base::TimeDelta::FromSeconds(30);
+  clock->SetNow(later_in_day);
+  service->AddPoints(origin, 3);
+
+  last_engagement_time = base::Time::FromInternalValue(
+      profile()->GetPrefs()->GetInt64(prefs::kSiteEngagementLastUpdateTime));
+
+  ASSERT_FALSE(last_engagement_time.is_null());
+  EXPECT_EQ(last_engagement_time, current_day);
+  ASSERT_FALSE(service->last_engagement_time_.is_null());
+  EXPECT_EQ(service->last_engagement_time_, later_in_day);
+
+  // When the service is destroyed, the time should be persisted to disk.
+  service.reset(nullptr);
+  last_engagement_time = base::Time::FromInternalValue(
+      profile()->GetPrefs()->GetInt64(prefs::kSiteEngagementLastUpdateTime));
+
+  ASSERT_FALSE(last_engagement_time.is_null());
+  EXPECT_EQ(last_engagement_time, later_in_day);
+}