Set site engagement timestamps to privacy-respectful values when history is cleared.

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 <cmath>
@@ skipping 18 matching lines @@
 #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/history/core/browser/history_service.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.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;
 
 // Keys used in the variations params. Order matches
 // SiteEngagementScore::Variation enum.
 const char* kVariationNames[] = {
     "max_points_per_day",
     "decay_period_in_days",
     "decay_points",
     "navigation_points",
@@ skipping 213 matching lines @@
   double to_add = std::min(kMaxPoints - raw_score_,
                            GetMaxPointsPerDay() - points_added_today_);
   to_add = std::min(to_add, points);
 
   points_added_today_ += to_add;
   raw_score_ += to_add;
 
   last_engagement_time_ = now;
 }
 
-void SiteEngagementScore::Reset(double points) {
+void SiteEngagementScore::Reset(double points, const base::Time* updated_time) {
   raw_score_ = points;
   points_added_today_ = 0;
 
   // This must be set in order to prevent the score from decaying when read.
-  last_engagement_time_ = clock_->Now();
+  if (updated_time) {
+    last_engagement_time_ = *updated_time;
+    if (!last_shortcut_launch_time_.is_null())
+      last_shortcut_launch_time_ = *updated_time;
+  } else {
+    last_engagement_time_ = clock_->Now();
+  }
 }
 
 bool SiteEngagementScore::MaxPointsPerDayAdded() const {
   if (!last_engagement_time_.is_null() &&
       clock_->Now().LocalMidnight() != last_engagement_time_.LocalMidnight()) {
     return false;
   }
 
   return points_added_today_ == GetMaxPointsPerDay();
 }
@@ skipping 152 matching lines @@
                                                bool is_hidden) {
   SiteEngagementMetrics::RecordEngagement(
       is_hidden ? SiteEngagementMetrics::ENGAGEMENT_MEDIA_HIDDEN
                 : SiteEngagementMetrics::ENGAGEMENT_MEDIA_VISIBLE);
   AddPoints(url, is_hidden ? SiteEngagementScore::GetHiddenMediaPoints()
                            : SiteEngagementScore::GetVisibleMediaPoints());
   RecordMetrics();
 }
 
 void SiteEngagementService::ResetScoreForURL(const GURL& url, double score) {
-  DCHECK(url.is_valid());
-  DCHECK_GE(score, 0);
-  DCHECK_LE(score, SiteEngagementScore::kMaxPoints);
-
-  HostContentSettingsMap* settings_map =
-    HostContentSettingsMapFactory::GetForProfile(profile_);
-  std::unique_ptr<base::DictionaryValue> score_dict =
-      GetScoreDictForOrigin(settings_map, url);
-  SiteEngagementScore engagement_score(clock_.get(), *score_dict);
-
-  engagement_score.Reset(score);
-  if (score == 0) {
-    settings_map->SetWebsiteSettingDefaultScope(
-        url, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
-        nullptr);
-    return;
-  }
-
-  if (engagement_score.UpdateScoreDict(score_dict.get())) {
-    settings_map->SetWebsiteSettingDefaultScope(
-        url, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
-        score_dict.release());
-  }
+  ResetScoreAndAccessTimesForURL(url, score, nullptr);
 }
 
 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->GetCountsForOrigins(
+  hs->GetCountsAndLastVisitForOrigins(
       std::set<GURL>(origins.begin(), origins.end()),
-      base::Bind(&SiteEngagementService::GetCountsForOriginsComplete,
-                 weak_factory_.GetWeakPtr(), origins, expired));
+      base::Bind(
+          &SiteEngagementService::GetCountsAndLastVisitForOriginsComplete,
+          weak_factory_.GetWeakPtr(), hs, origins, expired));
 }
 
 void SiteEngagementService::SetLastShortcutLaunchTime(const GURL& url) {
   HostContentSettingsMap* settings_map =
     HostContentSettingsMapFactory::GetForProfile(profile_);
   std::unique_ptr<base::DictionaryValue> score_dict =
       GetScoreDictForOrigin(settings_map, url);
   SiteEngagementScore score(clock_.get(), *score_dict);
 
   // Record the number of days since the last launch in UMA. If the user's clock
@@ skipping 237 matching lines @@
     const std::map<GURL, double>& score_map) const {
   int total_origins = 0;
 
   for (const auto& value : score_map)
     if (value.second == SiteEngagementScore::kMaxPoints)
       ++total_origins;
 
   return total_origins;
 }
 
-void SiteEngagementService::GetCountsForOriginsComplete(
+void SiteEngagementService::GetCountsAndLastVisitForOriginsComplete(
+    history::HistoryService* history_service,
     const std::multiset<GURL>& deleted_origins,
     bool expired,
     const history::OriginCountMap& remaining_origins) {
+
+  // The most in-the-past option in the Clear Browsing Dialog aside from "all
+  // time" is 4 weeks ago. Set the last updated date to 4 weeks ago for origins
+  // where we can't find a valid last visit date.
+  base::Time now = clock_->Now();
+  base::Time four_weeks_ago =
+      now - base::TimeDelta::FromDays(FOUR_WEEKS_IN_DAYS);
+
   for (const auto& origin_to_count : remaining_origins) {
     GURL origin = origin_to_count.first;
-    int remaining = origin_to_count.second;
+    int remaining = origin_to_count.second.first;
+    base::Time last_visit = origin_to_count.second.second;
     int deleted = deleted_origins.count(origin);
 
     // Do not update engagement scores if the deletion was an expiry, but the
     // URL still has entries in history.
     if ((expired && remaining != 0) || deleted == 0)
       continue;
 
+    if (last_visit.is_null() || last_visit > now)
+      last_visit = four_weeks_ago;
+
+    // At this point, we are going to proportionally decay the origin's
+    // engagement, and reset its last visit date to the last visit to a URL
+    // under the origin in history. If this new last visit date is long enough
+    // in the past, the next time the origin's engagement is accessed the
+    // automatic decay will kick in - i.e. a double decay will have occurred.
+    // To prevent this, compute the decay that would have taken place since the
+    // new last visit and add it to the engagement at this point. When the
+    // engagement is next accessed, it will decay back to the proportionally
+    // reduced value rather than being decayed once here, and then once again
+    // when it is next accessed.
+    int undecay = 0;
+    int days_since_engagement = (now - last_visit).InDays();
+    if (days_since_engagement > 0) {
+      int periods = days_since_engagement /
+                    SiteEngagementScore::GetDecayPeriodInDays();
+      undecay = periods * SiteEngagementScore::GetDecayPoints();
+    }
+
     // Remove engagement proportional to the urls expired from the origin's
     // entire history.
     double proportion_remaining =
         static_cast<double>(remaining) / (remaining + deleted);

[benwells, 2016/04/19 07:28:19]

Nit: move proportion_remaining calculation up to line 759, so that all the code
to figure that out is together.

[dominickn, 2016/04/19 07:59:32]

Done.

-    ResetScoreForURL(origin, proportion_remaining * GetScore(origin));
+    ResetScoreAndAccessTimesForURL(
+        origin, (proportion_remaining * GetScore(origin)) + undecay,
+        &last_visit);
   }
 }
+
+void SiteEngagementService::ResetScoreAndAccessTimesForURL(
+    const GURL& url, double score, const base::Time* updated_time) {
+  DCHECK(url.is_valid());
+  DCHECK_GE(score, 0);
+  DCHECK_LE(score, SiteEngagementScore::kMaxPoints);

[benwells, 2016/04/19 07:28:19]

Should it be impossible for this DCHECK to fire? I'm not sure it is. You might
undecay it back up to beyone max points, in which case you want to cap it at max
points.

[dominickn, 2016/04/19 07:59:32]

Good point. Done.

+
+  HostContentSettingsMap* settings_map =
+      HostContentSettingsMapFactory::GetForProfile(profile_);
+  std::unique_ptr<base::DictionaryValue> score_dict =
+      GetScoreDictForOrigin(settings_map, url);
+  SiteEngagementScore engagement_score(clock_.get(), *score_dict);
+
+  engagement_score.Reset(score, updated_time);
+  if (score == 0) {
+    settings_map->SetWebsiteSettingDefaultScope(
+        url, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
+        nullptr);
+    return;
+  }
+
+  if (engagement_score.UpdateScoreDict(score_dict.get())) {
+    settings_map->SetWebsiteSettingDefaultScope(
+        url, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
+        score_dict.release());
+  }
+}