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 <vector>
 
 #include "base/command_line.h"
 #include "base/time/clock.h"
 #include "base/time/default_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_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 "content/public/browser/browser_thread.h"
 #include "url/gurl.h"
 
 namespace {
 
+// Length of time between metrics logging.
+const base::TimeDelta metrics_interval = base::TimeDelta::FromMinutes(60);
+
 // Delta within which to consider scores equal.
 const double kScoreDelta = 0.001;
 
 // Delta within which to consider internal time values equal. Internal time
 // values are in microseconds, so this delta comes out at one second.
 const double kTimeDelta = 1000000;
 
 scoped_ptr<ContentSettingsForOneType> GetEngagementContentSettings(
     HostContentSettingsMap* settings_map) {
   scoped_ptr<ContentSettingsForOneType> engagement_settings(
@@ skipping 71 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()) {
+    return false;
+  }
+
+  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 44 matching lines @@
 bool SiteEngagementService::IsEnabled() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableSiteEngagementService);
 }
 
 SiteEngagementService::SiteEngagementService(Profile* profile)
     : SiteEngagementService(profile, make_scoped_ptr(new base::DefaultClock)) {
   content::BrowserThread::PostAfterStartupTask(
       FROM_HERE, content::BrowserThread::GetMessageLoopProxyForThread(
                      content::BrowserThread::UI),
-      base::Bind(&SiteEngagementService::CleanupEngagementScores,
+      base::Bind(&SiteEngagementService::AfterStartupTask,
                  weak_factory_.GetWeakPtr()));
 }
 
 SiteEngagementService::~SiteEngagementService() {
 }
 
 void SiteEngagementService::HandleNavigation(const GURL& url,
                                              ui::PageTransition transition) {
+  SiteEngagementMetrics::RecordEngagement(
+      SiteEngagementMetrics::ENGAGEMENT_NAVIGATION);
   AddPoints(url, SiteEngagementScore::kNavigationPoints);
+  RecordMetrics();
 }
 
-void SiteEngagementService::HandleUserInput(const GURL& url) {
+void SiteEngagementService::HandleUserInput(
+    const GURL& url,
+    SiteEngagementMetrics::EngagementType type) {
+  SiteEngagementMetrics::RecordEngagement(type);
   AddPoints(url, SiteEngagementScore::kUserInputPoints);
+  RecordMetrics();
 }
 
 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_.get(), *score_dict);
 
   return score.Score();
 }
 
 double SiteEngagementService::GetTotalEngagementPoints() {
-  HostContentSettingsMap* settings_map =
-    HostContentSettingsMapFactory::GetForProfile(profile_);
-  scoped_ptr<ContentSettingsForOneType> engagement_settings =
-      GetEngagementContentSettings(settings_map);
+  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_.get(), *score_dict);
-    total_score += score.Score();
-  }
   return total_score;
 }
 
 std::map<GURL, double> SiteEngagementService::GetScoreMap() {
   HostContentSettingsMap* settings_map =
       HostContentSettingsMapFactory::GetForProfile(profile_);
   scoped_ptr<ContentSettingsForOneType> engagement_settings =
       GetEngagementContentSettings(settings_map);
 
   std::map<GURL, double> score_map;
@@ skipping 28 matching lines @@
         ContentSettingsPattern::FromURLNoWildcard(url));
     if (!pattern.IsValid())
       return;
 
     settings_map->SetWebsiteSetting(pattern, ContentSettingsPattern::Wildcard(),
                                     CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT,
                                     std::string(), score_dict.release());
   }
 }
 
+void SiteEngagementService::AfterStartupTask() {
+  CleanupEngagementScores();
+  RecordMetrics();
+}
+
 void SiteEngagementService::CleanupEngagementScores() {
   HostContentSettingsMap* settings_map =
     HostContentSettingsMapFactory::GetForProfile(profile_);
   scoped_ptr<ContentSettingsForOneType> engagement_settings =
       GetEngagementContentSettings(settings_map);
 
   for (const auto& site : *engagement_settings) {
     GURL origin(site.primary_pattern.ToString());
     if (origin.is_valid()) {
       scoped_ptr<base::DictionaryValue> score_dict =
           GetScoreDictForOrigin(settings_map, origin);
       SiteEngagementScore score(clock_.get(), *score_dict);
       if (score.Score() != 0)
         continue;
     }
 
     settings_map->SetWebsiteSetting(
         site.primary_pattern, ContentSettingsPattern::Wildcard(),
         CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(), nullptr);
   }
 }
 
+void SiteEngagementService::RecordMetrics() {
+  base::Time now = clock_->Now();
+  if (last_metrics_time_.is_null() ||
+      now - last_metrics_time_ >= metrics_interval) {
+    last_metrics_time_ = now;
+    std::map<GURL, double> score_map = GetScoreMap();
+
+    int origins_with_max_engagement = OriginsWithMaxEngagement(score_map);
+    int total_origins = score_map.size();
+    int percent_origins_with_max_engagement =
+        (total_origins == 0 ? 0 : (origins_with_max_engagement * 100) /
+                                      total_origins);
+
+    double total_engagement = GetTotalEngagementPoints();
+    double mean_engagement =
+        (total_origins == 0 ? 0 : total_engagement / total_origins);
+
+    SiteEngagementMetrics::RecordTotalOriginsEngaged(total_origins);
+    SiteEngagementMetrics::RecordTotalSiteEngagement(total_engagement);
+    SiteEngagementMetrics::RecordMeanEngagement(mean_engagement);
+    SiteEngagementMetrics::RecordMedianEngagement(
+        GetMedianEngagement(score_map));
+    SiteEngagementMetrics::RecordEngagementScores(score_map);
+
+    SiteEngagementMetrics::RecordOriginsWithMaxDailyEngagement(
+        OriginsWithMaxDailyEngagement());
+    SiteEngagementMetrics::RecordOriginsWithMaxEngagement(
+        origins_with_max_engagement);
+    SiteEngagementMetrics::RecordPercentOriginsWithMaxEngagement(
+        percent_origins_with_max_engagement);
+  }
+}
+
+double SiteEngagementService::GetMedianEngagement(
+    std::map<GURL, double>& score_map) {
+  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);
+
+  // Calculate the median as the middle value of the sorted engagement scores
+  // if there are an odd number of scores, or the average of the two middle
+  // scores otherwise.
+  std::sort(scores.begin(), scores.end());

[calamity, 2015/10/02 05:31:18]

Consider using std::nth_element to compute the median.

[dominickn, 2015/10/02 06:06:17]

I think this is a bit too micro-optimisation-ish to implement, plus it'll need 2
calls to nth_element (and an extra variable) to compute the even sized list
case.

+  size_t mid = scores.size() / 2;
+  if (scores.size() % 2 == 1)
+    return scores[mid];
+  else
+    return (scores[mid - 1] + scores[mid]) / 2;
+}
+
+int SiteEngagementService::OriginsWithMaxDailyEngagement() {
+  HostContentSettingsMap* settings_map =
+      HostContentSettingsMapFactory::GetForProfile(profile_);
+  scoped_ptr<ContentSettingsForOneType> engagement_settings =
+      GetEngagementContentSettings(settings_map);
+
+  int total_origins = 0;
+
+  // We cannot call GetScoreMap as we need the score objects, not raw scores.
+  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_.get(), *score_dict);
+    if (score.MaxPointsPerDayAdded())
+      ++total_origins;
+  }
+
+  return total_origins;
+}
+
+int SiteEngagementService::OriginsWithMaxEngagement(
+    std::map<GURL, double>& score_map) {
+  int total_origins = 0;
+
+  for (const auto& value : score_map)
+    if (value.second == SiteEngagementScore::kMaxPoints)
+      ++total_origins;
+
+  return total_origins;
+}