New user type introduced. Combines regular and supervised features.

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 40 matching lines @@
 const char kUserDisplayEmail[] = "UserDisplayEmail";
 
 // A dictionary that maps user IDs to OAuth token presence flag.
 const char kUserOAuthTokenStatus[] = "OAuthTokenStatus";
 
 // A dictionary that maps user IDs to a flag indicating whether online
 // authentication against GAIA should be enforced during the next sign-in.
 const char kUserForceOnlineSignin[] = "UserForceOnlineSignin";
 
 // A string pref containing the ID of the last user who logged in if it was
-// a regular user or an empty string if it was another type of user (guest,
-// kiosk, public account, etc.).
-const char kLastLoggedInRegularUser[] = "LastLoggedInRegularUser";
+// a user with gaia account (regular) or an empty string if it was another type

[bartfab (slow), 2014/11/27 12:51:51]

Nit: As before, I am not sure "regular" is actually helpful here.

+// of user (guest, kiosk, public account, etc.).
+const char kLastLoggedInGaiaUser[] = "LastLoggedInRegularUser";
 
 // A string pref containing the ID of the last active user.
 // In case of browser crash, this pref will be used to set active user after
 // session restore.
 const char kLastActiveUser[] = "LastActiveUser";
 
 // 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;
 
@@ skipping 12 matching lines @@
 void ResolveLocale(const std::string& raw_locale,
                    std::string* resolved_locale) {
   ignore_result(l10n_util::CheckAndResolveLocale(raw_locale, resolved_locale));
 }
 
 }  // namespace
 
 // static
 void UserManagerBase::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterListPref(kRegularUsers);
-  registry->RegisterStringPref(kLastLoggedInRegularUser, std::string());
+  registry->RegisterStringPref(kLastLoggedInGaiaUser, std::string());
   registry->RegisterDictionaryPref(kUserDisplayName);
   registry->RegisterDictionaryPref(kUserGivenName);
   registry->RegisterDictionaryPref(kUserDisplayEmail);
   registry->RegisterDictionaryPref(kUserOAuthTokenStatus);
   registry->RegisterDictionaryPref(kUserForceOnlineSignin);
   registry->RegisterStringPref(kLastActiveUser, std::string());
 }
 
 UserManagerBase::UserManagerBase(
     scoped_refptr<base::TaskRunner> task_runner,
@@ skipping 104 matching lines @@
   active_user_->set_is_logged_in(true);
   active_user_->set_is_active(true);
   active_user_->set_username_hash(username_hash);
 
   // Place user who just signed in to the top of the logged in users.
   logged_in_users_.insert(logged_in_users_.begin(), active_user_);
   SetLRUUser(active_user_);
 
   if (!primary_user_) {
     primary_user_ = active_user_;
-    if (primary_user_->GetType() == USER_TYPE_REGULAR)
-      SendRegularUserLoginMetrics(user_id);
+    if (primary_user_->HasGaiaAccount())
+      SendGaiaUserLoginMetrics(user_id);
   }
 
   UMA_HISTOGRAM_ENUMERATION(
       "UserManager.LoginUserType", active_user_->GetType(), NUM_USER_TYPES);
 
   GetLocalState()->SetString(
-      kLastLoggedInRegularUser,
-      (active_user_->GetType() == USER_TYPE_REGULAR) ? user_id : "");
+      kLastLoggedInGaiaUser, active_user_->HasGaiaAccount() ? user_id : "");
 
   NotifyOnLogin();
   PerformPostUserLoggedInActions(browser_restart);
 }
 
 void UserManagerBase::SwitchActiveUser(const std::string& user_id) {
   User* user = FindUserAndModify(user_id);
   if (!user) {
     NOTREACHED() << "Switching to a non-existing user";
     return;
   }
   if (user == active_user_) {
     NOTREACHED() << "Switching to a user who is already active";
     return;
   }
   if (!user->is_logged_in()) {
     NOTREACHED() << "Switching to a user that is not logged in";
     return;
   }
-  if (user->GetType() != USER_TYPE_REGULAR) {
-    NOTREACHED() << "Switching to a non-regular user";
+  if (!user->HasGaiaAccount()) {
+    NOTREACHED() <<
+        "Switching to a user without gaia account (non-regular one)";

[bartfab (slow), 2014/11/27 12:51:51]

Nit: As before, "non-regular one" is not really helpful. We have so many user
types now that "regular" vs. "non-regular" is pretty murky.

     return;
   }
   if (user->username_hash().empty()) {
     NOTREACHED() << "Switching to a user that doesn't have username_hash set";
     return;
   }
 
   DCHECK(active_user_);
   active_user_->set_is_active(false);
   user->set_is_active(true);
@@ skipping 282 matching lines @@
 bool UserManagerBase::CanCurrentUserLock() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() && active_user_->can_lock();
 }
 
 bool UserManagerBase::IsUserLoggedIn() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return active_user_;
 }
 
-bool UserManagerBase::IsLoggedInAsRegularUser() const {
+bool UserManagerBase::IsLoggedInAsUserWithGaiaAccount() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
-  return IsUserLoggedIn() && active_user_->GetType() == USER_TYPE_REGULAR;
+  return IsUserLoggedIn() && active_user_->HasGaiaAccount();
+}
+
+bool UserManagerBase::IsLoggedInAsRegularSupervisedUser() const {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  return IsUserLoggedIn() && active_user_->GetType() ==
+      USER_TYPE_REGULAR_SUPERVISED;
 }
 
 bool UserManagerBase::IsLoggedInAsDemoUser() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() && active_user_->GetType() == USER_TYPE_RETAIL_MODE;
 }
 
 bool UserManagerBase::IsLoggedInAsPublicAccount() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() &&
@@ skipping 37 matching lines @@
   }
 
   // Data belonging to the owner, anyone found on the user list and obsolete
   // public accounts whose data has not been removed yet is not ephemeral.
   if (user_id == GetOwnerEmail() || UserExistsInList(user_id) ||
       IsPublicAccountMarkedForRemoval(user_id)) {
     return false;
   }
 
   // Data belonging to the currently logged-in user is ephemeral when:
-  // a) The user logged into a regular account while the ephemeral users policy
-  //    was enabled.
+  // a) The user logged into a regular gaia account while the ephemeral users

[bartfab (slow), 2014/11/27 12:51:51]

Nit: s/into a regular/in with a/ (there is not such thing as a "regular gaia
account")

+  //    policy was enabled.
   //    - or -
   // b) The user logged into any other account type.
   if (IsUserLoggedIn() && (user_id == GetLoggedInUser()->email()) &&
-      (is_current_user_ephemeral_regular_user_ || !IsLoggedInAsRegularUser())) {
+      (is_current_user_ephemeral_regular_user_ ||
+       !IsLoggedInAsUserWithGaiaAccount())) {
     return true;
   }
 
   // Data belonging to any other user is ephemeral when:
   // a) Going through the regular login flow and the ephemeral users policy is
   //    enabled.
   //    - or -
   // b) The browser is restarting after a crash.
   return AreEphemeralUsersEnabled() ||
          session_manager::SessionManager::HasBrowserRestarted();
@@ skipping 21 matching lines @@
   session_state_observer_list_.RemoveObserver(obs);
 }
 
 void UserManagerBase::NotifyLocalStateChanged() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   FOR_EACH_OBSERVER(
       UserManager::Observer, observer_list_, LocalStateChanged(this));
 }
 
 bool UserManagerBase::CanUserBeRemoved(const User* user) const {
   // Only regular and supervised users are allowed to be manually removed.

[bartfab (slow), 2014/11/27 12:51:51]

Nit: "regular" and "supervised" overlap now that we also have "regular
supervised." How about "Only gaia and legacy supervised users"?

-  if (!user || (user->GetType() != USER_TYPE_REGULAR &&
-                user->GetType() != USER_TYPE_SUPERVISED)) {
+  if (!user || !(user->HasGaiaAccount() || user->IsSupervised()))
     return false;
-  }
 
   // Sanity check: we must not remove single user unless it's an enterprise
   // device. This check may seem redundant at a first sight because
   // this single user must be an owner and we perform special check later
   // in order not to remove an owner. However due to non-instant nature of
   // ownership assignment this later check may sometimes fail.
   // See http://crosbug.com/12723
   if (users_.size() < 2 && !IsEnterpriseManaged())
     return false;
 
@@ skipping 239 matching lines @@
     const std::string& user_id) {
   ListPrefUpdate prefs_users_update(GetLocalState(), kRegularUsers);
   prefs_users_update->Clear();
   User* user = NULL;
   for (UserList::iterator it = users_.begin(); it != users_.end();) {
     const std::string user_email = (*it)->email();
     if (user_email == user_id) {
       user = *it;
       it = users_.erase(it);
     } else {
-      if ((*it)->GetType() == USER_TYPE_REGULAR ||
-          (*it)->GetType() == USER_TYPE_SUPERVISED) {
+      if ((*it)->HasGaiaAccount() || (*it)->IsSupervised())
         prefs_users_update->Append(new base::StringValue(user_email));
-      }
       ++it;
     }
   }
   return user;
 }
 
 void UserManagerBase::NotifyActiveUserChanged(const User* active_user) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   FOR_EACH_OBSERVER(UserManager::UserSessionStateObserver,
                     session_state_observer_list_,
@@ skipping 63 matching lines @@
   GetLocalState()->SetString(kLastActiveUser, user->email());
   GetLocalState()->CommitPendingWrite();
 
   UserList::iterator it =
       std::find(lru_logged_in_users_.begin(), lru_logged_in_users_.end(), user);
   if (it != lru_logged_in_users_.end())
     lru_logged_in_users_.erase(it);
   lru_logged_in_users_.insert(lru_logged_in_users_.begin(), user);
 }
 
-void UserManagerBase::SendRegularUserLoginMetrics(const std::string& user_id) {
+void UserManagerBase::SendGaiaUserLoginMetrics(const std::string& user_id) {
   // If this isn't the first time Chrome was run after the system booted,
   // assume that Chrome was restarted because a previous session ended.
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kFirstExecAfterBoot)) {
     const std::string last_email =
-        GetLocalState()->GetString(kLastLoggedInRegularUser);
+        GetLocalState()->GetString(kLastLoggedInGaiaUser);
     const base::TimeDelta time_to_login =
         base::TimeTicks::Now() - manager_creation_time_;
     if (!last_email.empty() && user_id != last_email &&
         time_to_login.InSeconds() <= kLogoutToLoginDelayMaxSec) {
       UMA_HISTOGRAM_CUSTOM_COUNTS("UserManager.LogoutToLoginDelay",
                                   time_to_login.InSeconds(),
                                   0,
                                   kLogoutToLoginDelayMaxSec,
                                   50);
     }
@@ skipping 30 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