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());
+  }
 }
+
+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);
+}