Remove data belonging to a public account when the account is removed

chrome/browser/chromeos/login/user_manager_impl.cc

 // Copyright (c) 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/user_manager_impl.h"
 
 #include <cstddef>
 #include <set>
-#include <vector>
 
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
@@ skipping 111 matching lines @@
   chromeos::UserManager::Get()->RemoveUserFromList(user_email);
   cryptohome::AsyncMethodCaller::GetInstance()->AsyncRemove(
       user_email, base::Bind(&OnRemoveUserComplete, user_email));
 
   if (delegate)
     delegate->OnUserRemoved(user_email);
 }
 
 // Helper function that copies users from |users_list| to |users_vector| and
 // |users_set|. Duplicates and users already present in |existing_users| are
-// skipped. The |logged_in_user| is also skipped and the return value
-// indicates whether that user was found in |users_list|.
-bool ParseUserList(const ListValue& users_list,
+// skipped.
+void ParseUserList(const ListValue& users_list,
                    const std::set<std::string>& existing_users,
-                   const std::string& logged_in_user,
                    std::vector<std::string>* users_vector,
                    std::set<std::string>* users_set) {
   users_vector->clear();
   users_set->clear();
-  bool logged_in_user_on_list = false;
   for (size_t i = 0; i < users_list.GetSize(); ++i) {
     std::string email;
     if (!users_list.GetString(i, &email) || email.empty()) {
       LOG(ERROR) << "Corrupt entry in user list at index " << i << ".";
       continue;
     }
     if (existing_users.find(email) != existing_users.end() ||
         !users_set->insert(email).second) {
       LOG(ERROR) << "Duplicate user: " << email;
       continue;
     }
-    if (email == logged_in_user) {
-      logged_in_user_on_list = true;
-      continue;
-    }
     users_vector->push_back(email);
   }
-  users_set->erase(logged_in_user);
-  return logged_in_user_on_list;
 }
 
 }  // namespace
 
 // static
 void UserManager::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterListPref(kRegularUsers);
   registry->RegisterListPref(kPublicAccounts);
   registry->RegisterListPref(kLocallyManagedUsersFirstRun);
   registry->RegisterIntegerPref(kLocallyManagedUsersNextId, 0);
@@ skipping 666 matching lines @@
   const ListValue* prefs_public_accounts =
       local_state->GetList(kPublicAccounts);
   const DictionaryValue* prefs_display_names =
       local_state->GetDictionary(kUserDisplayName);
   const DictionaryValue* prefs_display_emails =
       local_state->GetDictionary(kUserDisplayEmail);
 
   // Load regular users and locally managed users.
   std::vector<std::string> regular_users;
   std::set<std::string> regular_users_set;
-  ParseUserList(*prefs_regular_users, std::set<std::string>(), "",
+  ParseUserList(*prefs_regular_users, std::set<std::string>(),
                 &regular_users, &regular_users_set);
   for (std::vector<std::string>::const_iterator it = regular_users.begin();
        it != regular_users.end(); ++it) {
     User* user = NULL;
     const std::string domain = gaia::ExtractDomainName(*it);
     if (domain == UserManager::kLocallyManagedUserDomain) {
       user = User::CreateLocallyManagedUser(*it);
     } else {
       user = User::CreateRegularUser(*it);
       user->set_oauth_token_status(LoadUserOAuthStatus(*it));
     }
     users_.push_back(user);
 
     string16 display_name;
     if (prefs_display_names->GetStringWithoutPathExpansion(*it,
                                                            &display_name)) {
       user->set_display_name(display_name);
     }
 
     std::string display_email;
     if (prefs_display_emails->GetStringWithoutPathExpansion(*it,
                                                             &display_email)) {
       user->set_display_email(display_email);
     }
   }
 
   // Load public accounts.
   std::vector<std::string> public_accounts;
   std::set<std::string> public_accounts_set;
-  ParseUserList(*prefs_public_accounts, regular_users_set, "",
+  ParseUserList(*prefs_public_accounts, regular_users_set,
                 &public_accounts, &public_accounts_set);
   for (std::vector<std::string>::const_iterator it = public_accounts.begin();
        it != public_accounts.end(); ++it) {
     users_.push_back(User::CreatePublicAccountUser(*it));
     UpdatePublicAccountDisplayName(*it);
   }
 
   user_image_manager_->LoadUserImages(users_);
 }
 
@@ skipping 278 matching lines @@
       if ((*it)->GetType() == User::USER_TYPE_REGULAR ||
           (*it)->GetType() == User::USER_TYPE_LOCALLY_MANAGED) {
         prefs_users_update->Append(new base::StringValue(user_email));
       }
       ++it;
     }
   }
   return user;
 }
 
+void UserManagerImpl::CleanUpPublicAccountNonCryptohomeData(
+    const std::vector<std::string>& old_public_accounts) {
+  std::set<std::string> users;
+  for (UserList::const_iterator it = users_.begin(); it != users_.end(); ++it)
+    users.insert((*it)->email());
+
+  // If the user is logged into a public account that has been removed from the
+  // user list, mark the account's data as pending removal after logout.
+  if (IsLoggedInAsPublicAccount()) {
+    const std::string active_user_id = GetActiveUser()->email();
+    if (users.find(active_user_id) == users.end()) {
+      g_browser_process->local_state()->SetString(
+          kPublicAccountPendingDataRemoval, active_user_id);
+      users.insert(active_user_id);
+    }
+  }
+
+  // Remove the data belonging to any other public accounts that are no longer
+  // found on the user list.
+  for (std::vector<std::string>::const_iterator
+           it = old_public_accounts.begin();
+       it != old_public_accounts.end(); ++it) {
+    if (users.find(*it) == users.end())
+      RemoveNonCryptohomeData(*it);
+  }
+}
+
 bool UserManagerImpl::UpdateAndCleanUpPublicAccounts(
     const base::ListValue& public_accounts) {
   PrefService* local_state = g_browser_process->local_state();
 
   // Determine the currently logged-in user's email.
   std::string active_user_email;
   if (IsUserLoggedIn())
     active_user_email = GetLoggedInUser()->email();
 
   // If there is a public account whose data is pending removal and the user is
@@ skipping 13 matching lines @@
   for (UserList::const_iterator it = users_.begin(); it != users_.end(); ++it) {
     if ((*it)->GetType() == User::USER_TYPE_PUBLIC_ACCOUNT)
       old_public_accounts.push_back((*it)->email());
     else
       regular_users.insert((*it)->email());
   }
 
   // Get the new list of public accounts from policy.
   std::vector<std::string> new_public_accounts;
   std::set<std::string> new_public_accounts_set;
-  if (!ParseUserList(public_accounts, regular_users, active_user_email,
-                     &new_public_accounts, &new_public_accounts_set) &&
-      IsLoggedInAsPublicAccount()) {
-    // If the user is currently logged into a public account that has been
-    // removed from the list, mark the account's data as pending removal after
-    // logout.
-    local_state->SetString(kPublicAccountPendingDataRemoval,
-                           active_user_email);
-  }
+  ParseUserList(public_accounts, regular_users,
+                &new_public_accounts, &new_public_accounts_set);
 
   // Persist the new list of public accounts in a pref.
   ListPrefUpdate prefs_public_accounts_update(local_state, kPublicAccounts);
   scoped_ptr<base::ListValue> prefs_public_accounts(public_accounts.DeepCopy());
   prefs_public_accounts_update->Swap(prefs_public_accounts.get());
 
   // If the list of public accounts has not changed, return.
   if (new_public_accounts.size() == old_public_accounts.size()) {
     bool changed = false;
     for (size_t i = 0; i < new_public_accounts.size(); ++i) {
@@ skipping 24 matching lines @@
     if (IsLoggedInAsPublicAccount() && *it == active_user_email)
       users_.insert(users_.begin(), GetLoggedInUser());
     else
       users_.insert(users_.begin(), User::CreatePublicAccountUser(*it));
     UpdatePublicAccountDisplayName(*it);
   }
 
   user_image_manager_->LoadUserImages(
       UserList(users_.begin(), users_.begin() + new_public_accounts.size()));
 
+  // Remove data belonging to public accounts that are no longer found on the
+  // user list.
+  CleanUpPublicAccountNonCryptohomeData(old_public_accounts);
+
   return true;
 }
 
 void UserManagerImpl::UpdatePublicAccountDisplayName(
     const std::string& username) {
   std::string display_name;
 
   if (device_local_account_policy_service_) {
     policy::DeviceLocalAccountPolicyBroker* broker =
         device_local_account_policy_service_->GetBrokerForAccount(username);
@@ skipping 207 matching lines @@
         case DEVICE_LOCAL_ACCOUNT_TYPE_KIOSK_APP:
           // TODO(mnissler, nkostylev, bartfab): Process Kiosk Apps within the
           // standard login framework: http://crbug.com/234694
           break;
       }
     }
   }
 }
 
 }  // namespace chromeos