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"
 #include "base/time/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_service_factory.h"
 #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 "url/gurl.h"
 
 namespace {
 
 // Delta within which to consider scores equal.
 const double kScoreDelta = 0.001;
@@ skipping 70 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;
+  }
+
+  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) {
   AddPoints(url, SiteEngagementScore::kNavigationPoints);
 }
 
 void SiteEngagementService::HandleUserInput(const GURL& url) {
   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 21 matching lines @@
   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.
+  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.
+  if (score.Score() == SiteEngagementScore::kMaxPoints) {
+    SiteEngagementMetrics::RecordOriginsWithMaxEngagement(
+        OriginsWithMaxEngagement());

[calamity, 2015/09/28 07:33:48]

Hmm. Does this mean we will be re-recording these stats for maxed origins?

e.g an origin reaches 100, the next input comes in and triggers this code again.

We need to keep track of the old value and only do this on a transition.

[dominickn, 2015/09/29 02:29:36]

Done.

+  }
 }
+
+int SiteEngagementService::OriginsWithMaxDailyEngagement() {
+  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::RecordEngagementByOrigin(score_map);
+}