Add UMA metrics to the site engagement service.

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 "base/command_line.h"
@@ skipping 84 matching lines @@
   double to_add =
       std::min(kMaxPoints - raw_score_, kMaxPointsPerDay - 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()) {
+    points_added_today_ = 0;

[benwells, 2015/09/30 00:10:54]

Why is this updated? When originally writing this code I tried to make the
internals not update unless they were going to be written to disk to make it
simpler to reason about.

[dominickn, 2015/10/01 01:12:02]

I added this update to ensure that day boundary effects didn't give false
positives when recording the number of maxed daily origins. This is the only
place where this attribute is read without the score being incremented as well
(and hence written). Do you think that the boundary effect is trivial enough to
skip this check entirely?

+  }
+
+  return points_added_today_ == kMaxPointsPerDay;
+}
+
 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,
                       &last_engagement_time_internal_orig);
   bool changed =
@@ skipping 41 matching lines @@
 }
 
 // static
 bool SiteEngagementService::IsEnabled() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableSiteEngagementService);
 }
 
 SiteEngagementService::SiteEngagementService(Profile* profile)
     : profile_(profile) {
+  RecordStartupUmaStats();
 }
 
 SiteEngagementService::~SiteEngagementService() {
 }
 
 void SiteEngagementService::HandleNavigation(const GURL& url,
                                              ui::PageTransition transition) {
+  SiteEngagementMetrics::RecordEngagement(
+      SiteEngagementMetrics::ENGAGEMENT_NAVIGATION);
   AddPoints(url, SiteEngagementScore::kNavigationPoints);
 }
 
-void SiteEngagementService::HandleUserInput(const GURL& url) {
+void SiteEngagementService::HandleUserInput(
+    const GURL& url,
+    SiteEngagementMetrics::EngagementType type) {
+  SiteEngagementMetrics::RecordEngagement(type);
   AddPoints(url, SiteEngagementScore::kUserInputPoints);
 }
 
 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_, *score_dict);
 
   return score.Score();
 }
 
 double SiteEngagementService::GetTotalEngagementPoints() {
-  HostContentSettingsMap* settings_map =
-    HostContentSettingsMapFactory::GetForProfile(profile_);
-  ContentSettingsForOneType engagement_settings;
-  settings_map->GetSettingsForOneType(CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT,
-                                      std::string(), &engagement_settings);
+  std::map<GURL, double> score_map = GetScoreMap();
+
   double total_score = 0;
-  for (const auto& site : engagement_settings) {
-    GURL origin(site.primary_pattern.ToString());
-    if (!origin.is_valid())
-      continue;
+  for (const auto& value : score_map)
+    total_score += value.second;
 
-    scoped_ptr<base::DictionaryValue> score_dict =
-        GetScoreDictForOrigin(settings_map, origin);
-    SiteEngagementScore score(&clock_, *score_dict);
-    total_score += score.Score();
-  }
   return total_score;
 }
 
 std::map<GURL, double> SiteEngagementService::GetScoreMap() {
   std::map<GURL, double> score_map;
   HostContentSettingsMap* settings_map =
       HostContentSettingsMapFactory::GetForProfile(profile_);
   ContentSettingsForOneType engagement_settings;
   settings_map->GetSettingsForOneType(CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT,
                                       std::string(), &engagement_settings);
@@ skipping 10 matching lines @@
   return score_map;
 }
 
 void SiteEngagementService::AddPoints(const GURL& url, double points) {
   HostContentSettingsMap* settings_map =
     HostContentSettingsMapFactory::GetForProfile(profile_);
   scoped_ptr<base::DictionaryValue> score_dict =
       GetScoreDictForOrigin(settings_map, url);
   SiteEngagementScore score(&clock_, *score_dict);
 
+  double old_score = score.Score();
+
   score.AddPoints(points);
   if (score.UpdateScoreDict(score_dict.get())) {
     ContentSettingsPattern pattern(
         ContentSettingsPattern::FromURLNoWildcard(url));
     if (!pattern.IsValid())
       return;
 
     settings_map->SetWebsiteSetting(pattern, ContentSettingsPattern::Wildcard(),
                                     CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT,
                                     std::string(), score_dict.release());
   }
+
+  // If the origin has now received the maximum number of points it can today,
+  // record a UMA statistic of all of the origins with maxed daily engagement.
+  // As this is recorded each time an origin reaches the maximum, a client with
+  // N maxed origins will have recorded a statistic for 1, 2, ..., N-1, N.
+  if (score.MaxPointsPerDayAdded()) {
+    SiteEngagementMetrics::RecordOriginsWithMaxDailyEngagement(
+        OriginsWithMaxDailyEngagement());
+  }
+
+  // If the origin has now received the maximum total number of points,
+  // record a UMA statistic of all of the origins with maximum total points.
+  double new_score = score.Score();
+  if (old_score != new_score && new_score == SiteEngagementScore::kMaxPoints) {
+    SiteEngagementMetrics::RecordOriginsWithMaxEngagement(
+        OriginsWithMaxEngagement());
+  }
 }
+
+int SiteEngagementService::OriginsWithMaxDailyEngagement() {

[benwells, 2015/09/30 00:10:54]

Is there a reason not to use GetScoreMap to implement this? Its strange that you
updated GetTotalEngagementPoints to use GetScoreMap but don't use it here.

[dominickn, 2015/10/01 01:12:02]

The main reason was to avoid a double-loop over all of the origins: one to
construct the score map, and the second to iterate over it again and check all
the origins for maxed daily scores. If you think this cost is okay, then I'm
happy to use GetScoreMap.

+  HostContentSettingsMap* settings_map =
+      HostContentSettingsMapFactory::GetForProfile(profile_);
+  ContentSettingsForOneType engagement_settings;
+  settings_map->GetSettingsForOneType(CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT,
+                                      std::string(), &engagement_settings);
+  int total_origins = 0;
+  for (const auto& site : engagement_settings) {
+    GURL origin(site.primary_pattern.ToString());
+    if (!origin.is_valid())
+      continue;
+
+    scoped_ptr<base::DictionaryValue> score_dict =
+        GetScoreDictForOrigin(settings_map, origin);
+    SiteEngagementScore score(&clock_, *score_dict);
+    if (score.MaxPointsPerDayAdded())
+      total_origins += 1;
+  }
+
+  return total_origins;
+}
+
+int SiteEngagementService::OriginsWithMaxEngagement() {
+  std::map<GURL, double> score_map = GetScoreMap();
+  int total_origins = 0;
+
+  for (const auto& value : score_map)
+    if (value.second == SiteEngagementScore::kMaxPoints)
+      ++total_origins;
+
+  return total_origins;
+}
+
+void SiteEngagementService::RecordStartupUmaStats() {
+  std::map<GURL, double> score_map = GetScoreMap();
+
+  double total_score = 0;
+  for (const auto& value : score_map)
+    total_score += value.second;
+
+  SiteEngagementMetrics::RecordTotalOriginsEngaged(score_map.size());
+  SiteEngagementMetrics::RecordTotalSiteEngagement(total_score);
+  SiteEngagementMetrics::RecordEngagementScore(score_map);
+}