Separate tracking for profiles that haven't been accessed in 4 weeks.

chrome/browser/profiles/profile_metrics.cc

 // Copyright (c) 2011 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/profiles/profile_metrics.h"
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
 
 namespace {
 
 const int kMaximumReportedProfileCount = 5;
+const int kMaximumDaysOfDisuse = 4 * 7;  // Should be integral number of weeks.
 
 struct ProfileCounts {
   size_t total;
   size_t signedin;
   size_t managed;
+  size_t unused;
 
-  ProfileCounts() : total(0), signedin(0), managed(0) {}
+  ProfileCounts() : total(0), signedin(0), managed(0), unused(0) {}
 };
 
 ProfileMetrics::ProfileType GetProfileType(
     const base::FilePath& profile_path) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   ProfileMetrics::ProfileType metric = ProfileMetrics::SECONDARY;
   ProfileManager* manager = g_browser_process->profile_manager();
   base::FilePath user_data_dir;
   // In unittests, we do not always have a profile_manager so check.
   if (manager) {
@@ skipping 13 matching lines @@
 
 bool CountProfileInformation(ProfileManager* manager, ProfileCounts* counts) {
   const ProfileInfoCache& info_cache = manager->GetProfileInfoCache();
   size_t number_of_profiles = info_cache.GetNumberOfProfiles();
   counts->total = number_of_profiles;
 
   // Ignore other metrics if we have no profiles, e.g. in Chrome Frame tests.
   if (!number_of_profiles)
     return false;
 
+  // Maximum age for "active" profile is 4 weeks.
+  base::Time oldest = base::Time::Now() -
+      base::TimeDelta::FromDays(kMaximumDaysOfDisuse);
+
   for (size_t i = 0; i < number_of_profiles; ++i) {
-    if (info_cache.ProfileIsManagedAtIndex(i))
-      counts->managed++;
-    if (!info_cache.GetUserNameOfProfileAtIndex(i).empty())
-      counts->signedin++;
+    if (info_cache.GetProfileActiveTimeAtIndex(i) < oldest) {

[rpetterson, 2014/01/22 21:40:27]

Overall I think this is an interesting metric to record. My only question is
whether you want to not record the other metrics if it is unused. Would it
better to know that I've got 10 managed profiles, 9 signed in profiles and 3 of
those unused? Would we want to know if the unused profiles were also managed
and/or signed in?

[bcwhite, 2014/01/23 14:07:38]

From the point-of-view of "signed in" tracking, we wanted to be able to discount
profiles that were created and never used, as frequently happens when people are
experimenting.

I think if we wanted the detail you mention, we'd have to duplicate all the
stats: managed, managed_unused, signedin, signedin_unused, total, total_unused. 
Otherwise, when looking at stats you'd have no idea if it was the signed-in &
managed profiles that were unused or the opposite.

+      counts->unused++;
+    } else {
+      if (info_cache.ProfileIsManagedAtIndex(i))
+        counts->managed++;
+      if (!info_cache.GetUserNameOfProfileAtIndex(i).empty())
+        counts->signedin++;
+    }
   }
   return true;
 }
 
 }  // namespace
 
 enum ProfileAvatar {
   AVATAR_GENERIC = 0,       // The names for avatar icons
   AVATAR_GENERIC_AQUA,
   AVATAR_GENERIC_BLUE,
@@ skipping 46 matching lines @@
   UMA_HISTOGRAM_COUNTS_100("Profile.NumberOfProfiles", counts.total);
 
   // Ignore other metrics if we have no profiles, e.g. in Chrome Frame tests.
   if (success) {
     UMA_HISTOGRAM_COUNTS_100("Profile.NumberOfManagedProfiles",
                              counts.managed);
     UMA_HISTOGRAM_COUNTS_100("Profile.PercentageOfManagedProfiles",
                              100 * counts.managed / counts.total);
     UMA_HISTOGRAM_COUNTS_100("Profile.NumberOfSignedInProfiles",
                              counts.signedin);
+    UMA_HISTOGRAM_COUNTS_100("Profile.NumberOfUnusedProfiles",
+                             counts.unused);
 
     UpdateReportedOSProfileStatistics(counts.total, counts.signedin);
   }
 }
 
 void ProfileMetrics::LogProfileAddNewUser(ProfileAdd metric) {
   DCHECK(metric < NUM_PROFILE_ADD_METRICS);
   UMA_HISTOGRAM_ENUMERATION("Profile.AddNewUser", metric,
                             NUM_PROFILE_ADD_METRICS);
   UMA_HISTOGRAM_ENUMERATION("Profile.NetUserCount", ADD_NEW_USER,
@@ skipping 141 matching lines @@
   UMA_HISTOGRAM_ENUMERATION("Profile.SyncSignIn",
                             GetProfileType(profile_path),
                             NUM_PROFILE_TYPE_METRICS);
 }
 
 void ProfileMetrics::LogProfileUpdate(const base::FilePath& profile_path) {
   UMA_HISTOGRAM_ENUMERATION("Profile.Update",
                             GetProfileType(profile_path),
                             NUM_PROFILE_TYPE_METRICS);
 }