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 200 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)
+    if (primary_user_->IsRegular())
       SendRegularUserLoginMetrics(user_id);
   }
 
   UMA_HISTOGRAM_ENUMERATION(
       "UserManager.LoginUserType", active_user_->GetType(), NUM_USER_TYPES);
 
   GetLocalState()->SetString(
-      kLastLoggedInRegularUser,
-      (active_user_->GetType() == USER_TYPE_REGULAR) ? user_id : "");
+      kLastLoggedInRegularUser, active_user_->IsRegular() ? 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) {
+  if (!user->IsRegular()) {
     NOTREACHED() << "Switching to a non-regular user";
     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);
@@ skipping 285 matching lines @@
   return IsUserLoggedIn() && active_user_->can_lock();
 }
 
 bool UserManagerBase::IsUserLoggedIn() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return active_user_;
 }
 
 bool UserManagerBase::IsLoggedInAsRegularUser() const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
-  return IsUserLoggedIn() && active_user_->GetType() == USER_TYPE_REGULAR;
+  return IsUserLoggedIn() && active_user_->IsRegular();
+}
+
+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 85 matching lines @@
 }
 
 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.
-  if (!user || (user->GetType() != USER_TYPE_REGULAR &&
-                user->GetType() != USER_TYPE_SUPERVISED)) {
+  if (!user || (!user->IsRegular() && !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)->IsRegular() || (*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 120 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