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

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 <stddef.h>
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/banners/app_banner_settings_helper.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/engagement/site_engagement_eviction_policy.h"
 #include "chrome/browser/engagement/site_engagement_metrics.h"
 #include "chrome/browser/engagement/site_engagement_score.h"
 #include "chrome/browser/engagement/site_engagement_service_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/pref_names.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "components/history/core/browser/history_service.h"
+#include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "url/gurl.h"
 
 namespace {
 
 const int FOUR_WEEKS_IN_DAYS = 28;
 
 // Global bool to ensure we only update the parameters from variations once.
 bool g_updated_from_variations = false;
@@ skipping 172 matching lines @@
         std::max(0, (now - last_launch).InDays()));
   }
   SiteEngagementMetrics::RecordEngagement(
       SiteEngagementMetrics::ENGAGEMENT_WEBAPP_SHORTCUT_LAUNCH);
 
   score.set_last_shortcut_launch_time(now);
   score.Commit();
 }
 
 double SiteEngagementService::GetScore(const GURL& url) const {
+  // Ensure that if engagement is stale, we clean things up before fetching the
+  // score.
+  if (IsLastEngagementStale())
+    CleanupEngagementScores(true);
+
   return CreateEngagementScore(url).GetScore();
 }
 
 double SiteEngagementService::GetTotalEngagementPoints() const {
   std::map<GURL, double> score_map = GetScoreMap();
 
   double total_score = 0;
   for (const auto& value : score_map)
     total_score += value.second;
 
   return total_score;
 }
 
 SiteEngagementService::SiteEngagementService(Profile* profile,
                                              std::unique_ptr<base::Clock> clock)
     : profile_(profile), clock_(std::move(clock)), weak_factory_(this) {
   // May be null in tests.
   history::HistoryService* history = HistoryServiceFactory::GetForProfile(
       profile, ServiceAccessType::IMPLICIT_ACCESS);
   if (history)
     history->AddObserver(this);
 }
 
 void SiteEngagementService::AddPoints(const GURL& url, double points) {
+  // Trigger a cleanup and date adjustment if it has been a substantial length
+  // of time since *any* engagement was recorded by the service. This will
+  // ensure that we do not decay scores when the user did not use the browser.
+  if (IsLastEngagementStale())
+    CleanupEngagementScores(true);
+
   SiteEngagementScore score = CreateEngagementScore(url);
-
   score.AddPoints(points);
   score.Commit();
+
+  SetLastEngagementTime(score.last_engagement_time());
 }
 
 void SiteEngagementService::AfterStartupTask() {
-  CleanupEngagementScores();
+  // Check if we need to reset last engagement times on startup - we want to
+  // avoid doing this in AddPoints() if possible. It is still necessary to check
+  // in AddPoints for people who never restart Chrome, but leave it open and
+  // their computer on standby.
+  CleanupEngagementScores(IsLastEngagementStale());
   RecordMetrics();
 }
 
-void SiteEngagementService::CleanupEngagementScores() {
+void SiteEngagementService::CleanupEngagementScores(
+    bool update_last_engagement_time) const {
+  // This method should not be called with |update_last_engagement_time| = true
+  // if the last engagement time isn't stale.
+  DCHECK(!update_last_engagement_time || IsLastEngagementStale());
+
   HostContentSettingsMap* settings_map =
       HostContentSettingsMapFactory::GetForProfile(profile_);
   std::unique_ptr<ContentSettingsForOneType> engagement_settings =
       GetEngagementContentSettings(settings_map);
 
+  // We want to rebase last engagement times relative to MaxDecaysPerScore
+  // periods of decay in the past.
+  base::Time now = clock_->Now();
+  base::Time last_engagement_time = GetLastEngagementTime();
+  base::Time rebase_time = now - GetMaxDecayPeriod();
+  base::Time new_last_engagement_time;
   for (const auto& site : *engagement_settings) {
     GURL origin(site.primary_pattern.ToString());
-    if (origin.is_valid() && GetScore(origin) != 0)
-      continue;
 
+    if (origin.is_valid()) {
+      SiteEngagementScore score = CreateEngagementScore(origin);
+      if (update_last_engagement_time) {
+        // Work out the offset between this score's last engagement time and the
+        // last time the service recorded any engagement. Set the score's last
+        // engagement time to rebase_time - offset to preserve its state,
+        // relative to the rebase date. This ensures that the score will decay
+        // the next time it is used, but will not decay too much.
+        DCHECK_LE(score.last_engagement_time(), rebase_time);
+        base::TimeDelta offset =
+            last_engagement_time - score.last_engagement_time();
+        base::Time rebase_score_time = rebase_time - offset;
+        score.set_last_engagement_time(rebase_score_time);
+        if (rebase_score_time > new_last_engagement_time)
+          new_last_engagement_time = rebase_score_time;
+
+        score.Commit();
+      }
+
+      if (score.GetScore() != 0)
+        continue;
+    }
+
+    // This origin has a score of 0. Wipe it from content settings.
     settings_map->SetWebsiteSettingDefaultScope(
         origin, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
         nullptr);
   }
+
+  // Set the last engagement time to be consistent with the scores. This will
+  // only occur if |update_last_engagement_time| is true.
+  if (!new_last_engagement_time.is_null())
+    SetLastEngagementTime(new_last_engagement_time);
 }
 
 void SiteEngagementService::RecordMetrics() {
   base::Time now = clock_->Now();
   if (last_metrics_time_.is_null() ||
       (now - last_metrics_time_).InMinutes() >= kMetricsIntervalInMinutes) {
     last_metrics_time_ = now;
     std::map<GURL, double> score_map = GetScoreMap();
 
     int origins_with_max_engagement = OriginsWithMaxEngagement(score_map);
@@ skipping 16 matching lines @@
 
     SiteEngagementMetrics::RecordOriginsWithMaxDailyEngagement(
         OriginsWithMaxDailyEngagement());
     SiteEngagementMetrics::RecordOriginsWithMaxEngagement(
         origins_with_max_engagement);
     SiteEngagementMetrics::RecordPercentOriginsWithMaxEngagement(
         percent_origins_with_max_engagement);
   }
 }
 
+base::Time SiteEngagementService::GetLastEngagementTime() const {
+  return base::Time::FromInternalValue(
+      profile_->GetPrefs()->GetInt64(prefs::kSiteEngagementLastUpdateTime));
+}
+
+void SiteEngagementService::SetLastEngagementTime(
+    base::Time last_engagement_time) const {
+  profile_->GetPrefs()->SetInt64(prefs::kSiteEngagementLastUpdateTime,
+                                 last_engagement_time.ToInternalValue());
+}
+
+base::TimeDelta SiteEngagementService::GetMaxDecayPeriod() const {
+  return base::TimeDelta::FromDays(
+             SiteEngagementScore::GetDecayPeriodInDays()) *
+         SiteEngagementScore::GetMaxDecaysPerScore();
+}
+
+base::TimeDelta SiteEngagementService::GetStalePeriod() const {
+  return GetMaxDecayPeriod() +
+         base::TimeDelta::FromHours(
+             SiteEngagementScore::GetLastEngagementGracePeriodInHours());
+}
+
 double SiteEngagementService::GetMedianEngagement(
     const std::map<GURL, double>& score_map) const {
   if (score_map.size() == 0)
     return 0;
 
   std::vector<double> scores;
   scores.reserve(score_map.size());
   for (const auto& value : score_map)
     scores.push_back(value.second);
 
@@ skipping 45 matching lines @@
   const GURL& url = web_contents->GetVisibleURL();
   SiteEngagementMetrics::RecordEngagement(type);
   AddPoints(url, SiteEngagementScore::GetUserInputPoints());
 
   RecordMetrics();
   FOR_EACH_OBSERVER(
       SiteEngagementObserver, observer_list_,
       OnEngagementIncreased(web_contents, url, GetScore(url)));
 }
 
+bool SiteEngagementService::IsLastEngagementStale() const {
+  // This only happens when Chrome is first run and the user has never recorded
+  // any engagement.
+  base::Time last_engagement_time = GetLastEngagementTime();
+  if (last_engagement_time.is_null())
+    return false;
+
+  return (clock_->Now() - last_engagement_time) >= GetStalePeriod();
+}
+
 void SiteEngagementService::OnURLsDeleted(
     history::HistoryService* history_service,
     bool all_history,
     bool expired,
     const history::URLRows& deleted_rows,
     const std::set<GURL>& favicon_urls) {
   std::multiset<GURL> origins;
   for (const history::URLRow& row : deleted_rows)
     origins.insert(row.url().GetOrigin());
 
   history::HistoryService* hs = HistoryServiceFactory::GetForProfile(
       profile_, ServiceAccessType::EXPLICIT_ACCESS);
   hs->GetCountsAndLastVisitForOrigins(
       std::set<GURL>(origins.begin(), origins.end()),
       base::Bind(
           &SiteEngagementService::GetCountsAndLastVisitForOriginsComplete,
           weak_factory_.GetWeakPtr(), hs, origins, expired));
 }
 
-const SiteEngagementScore SiteEngagementService::CreateEngagementScore(
+SiteEngagementScore SiteEngagementService::CreateEngagementScore(
     const GURL& origin) const {
   return SiteEngagementScore(
       clock_.get(), origin,
       HostContentSettingsMapFactory::GetForProfile(profile_));
-}
-
-SiteEngagementScore SiteEngagementService::CreateEngagementScore(
-    const GURL& origin) {
-  return SiteEngagementScore(
-      clock_.get(), origin,
-      HostContentSettingsMapFactory::GetForProfile(profile_));
 }
 
 int SiteEngagementService::OriginsWithMaxDailyEngagement() const {
   HostContentSettingsMap* settings_map =
       HostContentSettingsMapFactory::GetForProfile(profile_);
   std::unique_ptr<ContentSettingsForOneType> engagement_settings =
       GetEngagementContentSettings(settings_map);
 
   int total_origins = 0;
 
@@ skipping 80 matching lines @@
         SiteEngagementScore::kMaxPoints,
         (proportion_remaining * engagement_score.GetScore()) + undecay);
     engagement_score.Reset(score, last_visit);
     if (!engagement_score.last_shortcut_launch_time().is_null() &&
         engagement_score.last_shortcut_launch_time() > last_visit) {
       engagement_score.set_last_shortcut_launch_time(last_visit);
     }
 
     engagement_score.Commit();
   }
+
+  SetLastEngagementTime(now);
 }