UMA to track the reason for re-auth

components/user_manager/user_manager_base.cc

 // Copyright 2014 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 "components/user_manager/user_manager_base.h"
 
 #include <cstddef>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 70 matching lines @@
 
 // Key of obfuscated GAIA id value.
 const char kGAIAIdKey[] = "gaia_id";
 
 // Key of whether this user ID refers to a SAML user.
 const char kUsingSAMLKey[] = "using_saml";
 
 // Key of Device Id.
 const char kDeviceId[] = "device_id";
 
+// Key of the reason for re-auth.
+const char kReauthReasonKey[] = "reauth_reason";
+
 // Upper bound for a histogram metric reporting the amount of time between
 // one regular user logging out and a different regular user logging in.
 const int kLogoutToLoginDelayMaxSec = 1800;
 
 // Callback that is called after user removal is complete.
 void OnRemoveUserComplete(const std::string& user_email,
                           bool success,
                           cryptohome::MountError return_code) {
   // Log the error, but there's not much we can do.
   if (!success) {
@@ skipping 441 matching lines @@
   SetKnownUserBooleanPref(user_id, kUsingSAMLKey, using_saml);
 }
 
 bool UserManagerBase::FindUsingSAML(const std::string& user_id) {
   bool using_saml;
   if (GetKnownUserBooleanPref(user_id, kUsingSAMLKey, &using_saml))
     return using_saml;
   return false;
 }
 
+void UserManagerBase::UpdateReauthReason(const std::string& user_id,
+                                         const int reauth_reason) {
+  SetKnownUserIntegerPref(user_id, kReauthReasonKey, reauth_reason);
+}
+
+bool UserManagerBase::FindReauthReason(const std::string& user_id,
+                                       int* out_value) {
+  return GetKnownUserIntegerPref(user_id, kReauthReasonKey, out_value);
+}
+
 void UserManagerBase::UpdateUserAccountData(
     const std::string& user_id,
     const UserAccountData& account_data) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   SaveUserDisplayName(user_id, account_data.display_name());
 
   if (User* user = FindUserAndModify(user_id)) {
     base::string16 given_name = account_data.given_name();
     user->set_given_name(given_name);
@@ skipping 268 matching lines @@
     } else {
       user = User::CreateRegularUser(*it);
       int user_type;
       if (prefs_user_types->GetIntegerWithoutPathExpansion(*it, &user_type) &&
           user_type == USER_TYPE_CHILD) {
         ChangeUserChildStatus(user, true /* is child */);
       }
     }
     user->set_oauth_token_status(LoadUserOAuthStatus(*it));
     user->set_force_online_signin(LoadForceOnlineSignin(*it));
+    user->set_using_saml(FindUsingSAML(*it));
     users_.push_back(user);
 
     base::string16 display_name;
     if (prefs_display_names->GetStringWithoutPathExpansion(*it,
                                                            &display_name)) {
       user->set_display_name(display_name);
     }
 
     base::string16 given_name;
     if (prefs_given_names->GetStringWithoutPathExpansion(*it, &given_name)) {
@@ skipping 145 matching lines @@
 
   std::string last_active_user = GetLocalState()->GetString(kLastActiveUser);
   if (user_id == last_active_user)
     GetLocalState()->SetString(kLastActiveUser, std::string());
 }
 
 bool UserManagerBase::FindKnownUserPrefs(
     const UserID& user_id,
     const base::DictionaryValue** out_value) {
   PrefService* local_state = GetLocalState();
+
+  // Local State may not be initialized in tests.
+  if (!local_state)
+    return false;
+
   const base::ListValue* known_users = local_state->GetList(kKnownUsers);
   for (size_t i = 0; i < known_users->GetSize(); ++i) {
     const base::DictionaryValue* element = nullptr;
     if (known_users->GetDictionary(i, &element)) {
       if (UserMatches(user_id, *element)) {
         known_users->GetDictionary(i, out_value);
         return true;
       }
     }
   }
   return false;
 }
 
 void UserManagerBase::UpdateKnownUserPrefs(const UserID& user_id,
                                            const base::DictionaryValue& values,
                                            bool clear) {
-  ListPrefUpdate update(GetLocalState(), kKnownUsers);
+  PrefService* local_state = GetLocalState();
+
+  // Local State may not be initialized in tests.
+  if (!local_state)
+    return;
+
+  ListPrefUpdate update(local_state, kKnownUsers);
   for (size_t i = 0; i < update->GetSize(); ++i) {
     base::DictionaryValue* element = nullptr;
     if (update->GetDictionary(i, &element)) {
       if (UserMatches(user_id, *element)) {
         if (clear)
           element->Clear();
         element->MergeDictionary(&values);
         UpdateIdentity(user_id, *element);
         return;
       }
@@ skipping 11 matching lines @@
   const base::DictionaryValue* user_pref_dict = nullptr;
   if (!FindKnownUserPrefs(user_id, &user_pref_dict))
     return false;
 
   return user_pref_dict->GetString(path, out_value);
 }
 
 void UserManagerBase::SetKnownUserStringPref(const UserID& user_id,
                                              const std::string& path,
                                              const std::string& in_value) {
-  ListPrefUpdate update(GetLocalState(), kKnownUsers);
+  PrefService* local_state = GetLocalState();
+
+  // Local State may not be initialized in tests.
+  if (!local_state)
+    return;
+
+  ListPrefUpdate update(local_state, kKnownUsers);
   base::DictionaryValue dict;
   dict.SetString(path, in_value);
   UpdateKnownUserPrefs(user_id, dict, false);
 }
 
 bool UserManagerBase::GetKnownUserBooleanPref(const UserID& user_id,
                                               const std::string& path,
                                               bool* out_value) {
   const base::DictionaryValue* user_pref_dict = nullptr;
   if (!FindKnownUserPrefs(user_id, &user_pref_dict))
     return false;
 
   return user_pref_dict->GetBoolean(path, out_value);
 }
 
 void UserManagerBase::SetKnownUserBooleanPref(const UserID& user_id,
                                               const std::string& path,
                                               const bool in_value) {
-  ListPrefUpdate update(GetLocalState(), kKnownUsers);
+  PrefService* local_state = GetLocalState();
+
+  // Local State may not be initialized in tests.
+  if (!local_state)
+    return;
+
+  ListPrefUpdate update(local_state, kKnownUsers);
   base::DictionaryValue dict;
   dict.SetBoolean(path, in_value);
   UpdateKnownUserPrefs(user_id, dict, false);
 }
 
+bool UserManagerBase::GetKnownUserIntegerPref(const UserID& user_id,
+                                              const std::string& path,
+                                              int* out_value) {
+  const base::DictionaryValue* user_pref_dict = nullptr;
+  if (!FindKnownUserPrefs(user_id, &user_pref_dict))
+    return false;
+  return user_pref_dict->GetInteger(path, out_value);
+}
+
+void UserManagerBase::SetKnownUserIntegerPref(const UserID& user_id,
+                                              const std::string& path,
+                                              const int in_value) {
+  PrefService* local_state = GetLocalState();
+
+  // Local State may not be initialized in tests.
+  if (!local_state)
+    return;
+
+  ListPrefUpdate update(local_state, kKnownUsers);
+  base::DictionaryValue dict;
+  dict.SetInteger(path, in_value);
+  UpdateKnownUserPrefs(user_id, dict, false);
+}
+
 void UserManagerBase::UpdateGaiaID(const UserID& user_id,
                                    const std::string& gaia_id) {
   SetKnownUserStringPref(user_id, kGAIAIdKey, gaia_id);
 }
 
 bool UserManagerBase::FindGaiaID(const UserID& user_id,
                                  std::string* out_value) {
   return GetKnownUserStringPref(user_id, kGAIAIdKey, out_value);
 }
 
@@ skipping 170 matching lines @@
 }
 
 void UserManagerBase::DeleteUser(User* user) {
   const bool is_active_user = (user == active_user_);
   delete user;
   if (is_active_user)
     active_user_ = NULL;
 }
 
 }  // namespace user_manager