Various supervised user password fixes - 2

chrome/browser/chromeos/login/supervised_user_manager_impl.cc

 // Copyright 2013 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/chromeos/login/supervised_user_manager_impl.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
@@ skipping 56 matching lines @@
     "SupervisedUserPasswordSchema";
 
 // A map from user id to password salt.
 const char kSupervisedUserPasswordSalt[] =
     "SupervisedUserPasswordSalt";
 
 // A map from user id to password revision.
 const char kSupervisedUserPasswordRevision[] =
     "SupervisedUserPasswordRevision";
 
+// A map from user id to flag indicating if password should be updated upon
+// signin.
+const char kSupervisedUserNeedPasswordUpdate[] =
+    "SupervisedUserNeedPasswordUpdate";
+
+// A map from user id to flag indicating if cryptohome does not have signature
+// key.
+const char kSupervisedUserIncompleteKey[] = "SupervisedUserHasIncompleteKey";
+
 std::string LoadSyncToken(base::FilePath profile_dir) {
   std::string token;
   base::FilePath token_file =
       profile_dir.Append(chromeos::kManagedUserTokenFilename);
   VLOG(1) << "Loading" << token_file.value();
   if (!base::ReadFileToString(token_file, &token))
     return std::string();
   return token;
 }
 
@@ skipping 23 matching lines @@
   registry->RegisterStringPref(
       kLocallyManagedUserCreationTransactionUserId, "");
   registry->RegisterDictionaryPref(kManagedUserSyncId);
   registry->RegisterDictionaryPref(kManagedUserManagers);
   registry->RegisterDictionaryPref(kManagedUserManagerNames);
   registry->RegisterDictionaryPref(kManagedUserManagerDisplayEmails);
 
   registry->RegisterDictionaryPref(kSupervisedUserPasswordSchema);
   registry->RegisterDictionaryPref(kSupervisedUserPasswordSalt);
   registry->RegisterDictionaryPref(kSupervisedUserPasswordRevision);
+
+  registry->RegisterDictionaryPref(kSupervisedUserNeedPasswordUpdate);
+  registry->RegisterDictionaryPref(kSupervisedUserIncompleteKey);
 }
 
 SupervisedUserManagerImpl::SupervisedUserManagerImpl(UserManagerImpl* owner)
     : owner_(owner),
       cros_settings_(CrosSettings::Get()) {
   // SupervisedUserManager instance should be used only on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   authentication_.reset(new SupervisedUserAuthentication(this));
 }
 
@@ skipping 116 matching lines @@
 
 void SupervisedUserManagerImpl::GetPasswordInformation(
     const std::string& user_id,
     base::DictionaryValue* result) {
   int value;
   if (GetUserIntegerValue(user_id, kSupervisedUserPasswordSchema, &value))
     result->SetIntegerWithoutPathExpansion(kSchemaVersion, value);
   if (GetUserIntegerValue(user_id, kSupervisedUserPasswordRevision, &value))
     result->SetIntegerWithoutPathExpansion(kPasswordRevision, value);
 
+  bool flag;
+  if (GetUserBooleanValue(user_id, kSupervisedUserNeedPasswordUpdate, &flag))
+    result->SetBooleanWithoutPathExpansion(kRequirePasswordUpdate, flag);
+  if (GetUserBooleanValue(user_id, kSupervisedUserIncompleteKey, &flag))
+    result->SetBooleanWithoutPathExpansion(kHasIncompleteKey, flag);
+
   std::string salt;
   if (GetUserStringValue(user_id, kSupervisedUserPasswordSalt, &salt))
     result->SetStringWithoutPathExpansion(kSalt, salt);
 }
 
 void SupervisedUserManagerImpl::SetPasswordInformation(
       const std::string& user_id,
       const base::DictionaryValue* password_info) {
   int value;
   if (password_info->GetIntegerWithoutPathExpansion(kSchemaVersion, &value))
     SetUserIntegerValue(user_id, kSupervisedUserPasswordSchema, value);
   if (password_info->GetIntegerWithoutPathExpansion(kPasswordRevision, &value))
     SetUserIntegerValue(user_id, kSupervisedUserPasswordRevision, value);
 
+  bool flag;
+  if (password_info->GetBooleanWithoutPathExpansion(kRequirePasswordUpdate,
+                                                    &flag)) {
+    SetUserBooleanValue(user_id, kSupervisedUserNeedPasswordUpdate, flag);
+  }
+  if (password_info->GetBooleanWithoutPathExpansion(kHasIncompleteKey, &flag))
+    SetUserBooleanValue(user_id, kSupervisedUserIncompleteKey, flag);
+
   std::string salt;
   if (password_info->GetStringWithoutPathExpansion(kSalt, &salt))
     SetUserStringValue(user_id, kSupervisedUserPasswordSalt, salt);
   g_browser_process->local_state()->CommitPendingWrite();
 }
 
 bool SupervisedUserManagerImpl::GetUserStringValue(
     const std::string& user_id,
     const char* key,
     std::string* out_value) const {
   PrefService* local_state = g_browser_process->local_state();
   const base::DictionaryValue* dictionary = local_state->GetDictionary(key);
   return dictionary->GetStringWithoutPathExpansion(user_id, out_value);
 }
 
 bool SupervisedUserManagerImpl::GetUserIntegerValue(
     const std::string& user_id,
     const char* key,
     int* out_value) const {
   PrefService* local_state = g_browser_process->local_state();
   const base::DictionaryValue* dictionary = local_state->GetDictionary(key);
   return dictionary->GetIntegerWithoutPathExpansion(user_id, out_value);
 }
 
+bool SupervisedUserManagerImpl::GetUserBooleanValue(const std::string& user_id,
+                                                    const char* key,
+                                                    bool* out_value) const {
+  PrefService* local_state = g_browser_process->local_state();
+  const base::DictionaryValue* dictionary = local_state->GetDictionary(key);
+  return dictionary->GetBooleanWithoutPathExpansion(user_id, out_value);
+}
+
 void SupervisedUserManagerImpl::SetUserStringValue(
     const std::string& user_id,
     const char* key,
     const std::string& value) {
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate update(local_state, key);
   update->SetStringWithoutPathExpansion(user_id, value);
 }
 
 void SupervisedUserManagerImpl::SetUserIntegerValue(
     const std::string& user_id,
     const char* key,
     const int value) {
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate update(local_state, key);
   update->SetIntegerWithoutPathExpansion(user_id, value);
 }
 
+void SupervisedUserManagerImpl::SetUserBooleanValue(const std::string& user_id,
+                                                    const char* key,
+                                                    const bool value) {
+  PrefService* local_state = g_browser_process->local_state();
+  DictionaryPrefUpdate update(local_state, key);
+  update->SetBooleanWithoutPathExpansion(user_id, value);
+}
+
 const User* SupervisedUserManagerImpl::FindByDisplayName(
     const base::string16& display_name) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const UserList& users = owner_->GetUsers();
   for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
     if (((*it)->GetType() == User::USER_TYPE_LOCALLY_MANAGED) &&
         ((*it)->display_name() == display_name)) {
       return *it;
     }
   }
@@ skipping 83 matching lines @@
   ListPrefUpdate prefs_new_users_update(prefs, kLocallyManagedUsersFirstRun);
   prefs_new_users_update->Remove(base::StringValue(user_id), NULL);
 
   CleanPref(user_id, kManagedUserSyncId);
   CleanPref(user_id, kManagedUserManagers);
   CleanPref(user_id, kManagedUserManagerNames);
   CleanPref(user_id, kManagedUserManagerDisplayEmails);
   CleanPref(user_id, kSupervisedUserPasswordSalt);
   CleanPref(user_id, kSupervisedUserPasswordSchema);
   CleanPref(user_id, kSupervisedUserPasswordRevision);
+  CleanPref(user_id, kSupervisedUserNeedPasswordUpdate);
+  CleanPref(user_id, kSupervisedUserIncompleteKey);
 }
 
 void SupervisedUserManagerImpl::CleanPref(const std::string& user_id,
                                           const char* key) {
   PrefService* prefs = g_browser_process->local_state();
   DictionaryPrefUpdate dict_update(prefs, key);
   dict_update->RemoveWithoutPathExpansion(user_id, NULL);
 }
 
 bool SupervisedUserManagerImpl::CheckForFirstRun(const std::string& user_id) {
@@ skipping 42 matching lines @@
 }
 
 void SupervisedUserManagerImpl::ConfigureSyncWithToken(
     Profile* profile,
     const std::string& token) {
   if (!token.empty())
     ManagedUserServiceFactory::GetForProfile(profile)->InitSync(token);
 }
 
 }  // namespace chromeos