ChromeOS: Per-user time zone: refactor tests first.

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 <stddef.h>
 #include <set>
 #include <utility>
 
@@ skipping 87 matching lines @@
     DeleteUser(*it);
   }
   // These are pointers to the same User instances that were in users_ list.
   logged_in_users_.clear();
   lru_logged_in_users_.clear();
 
   DeleteUser(active_user_);
 }
 
 void UserManagerBase::Shutdown() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
 }
 
 const UserList& UserManagerBase::GetUsers() const {
   const_cast<UserManagerBase*>(this)->EnsureUsersLoaded();
   return users_;
 }
 
 const UserList& UserManagerBase::GetLoggedInUsers() const {
   return logged_in_users_;
 }
 
 const UserList& UserManagerBase::GetLRULoggedInUsers() const {
   return lru_logged_in_users_;
 }
 
 const AccountId& UserManagerBase::GetOwnerAccountId() const {
   return owner_account_id_;
 }
 
 void UserManagerBase::UserLoggedIn(const AccountId& account_id,
                                    const std::string& username_hash,
                                    bool browser_restart) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
 
   if (!last_session_active_account_id_initialized_) {
     last_session_active_account_id_ =
         AccountId::FromUserEmail(GetLocalState()->GetString(kLastActiveUser));
     last_session_active_account_id_initialized_ = true;
   }
 
   User* user = FindUserInListAndModify(account_id);
   if (active_user_ && user) {
     user->set_is_logged_in(true);
@@ skipping 110 matching lines @@
   if (AccountId::FromUserEmail(
           GetActiveUser()->GetAccountId().GetUserEmail()) !=
       last_session_active_account_id_)
     SwitchActiveUser(last_session_active_account_id_);
 
   // Make sure that this function gets run only once.
   last_session_active_account_id_.clear();
 }
 
 void UserManagerBase::OnSessionStarted() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
 
   CallUpdateLoginState();
   GetLocalState()->CommitPendingWrite();
 }
 
 void UserManagerBase::OnProfileInitialized(User* user) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
 
   // Mark the user as having an initialized session and persist this in
   // the known_user DB.
   user->set_profile_ever_initialized(true);
   known_user::SetProfileEverInitialized(user->GetAccountId(), true);
   GetLocalState()->CommitPendingWrite();
 }
 
 void UserManagerBase::RemoveUser(const AccountId& account_id,
                                  RemoveUserDelegate* delegate) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
 
   if (!CanUserBeRemoved(FindUser(account_id)))
     return;
 
   RemoveUserInternal(account_id, delegate);
 }
 
 void UserManagerBase::RemoveUserInternal(const AccountId& account_id,
                                          RemoveUserDelegate* delegate) {
   RemoveNonOwnerUserInternal(account_id, delegate);
 }
 
 void UserManagerBase::RemoveNonOwnerUserInternal(const AccountId& account_id,
                                                  RemoveUserDelegate* delegate) {
   if (delegate)
     delegate->OnBeforeUserRemoved(account_id);
   AsyncRemoveCryptohome(account_id);
   RemoveUserFromList(account_id);
 
   if (delegate)
     delegate->OnUserRemoved(account_id);
 }
 
 void UserManagerBase::RemoveUserFromList(const AccountId& account_id) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   RemoveNonCryptohomeData(account_id);
   if (user_loading_stage_ == STAGE_LOADED) {
     DeleteUser(RemoveRegularOrSupervisedUserFromList(account_id));
   } else if (user_loading_stage_ == STAGE_LOADING) {
     DCHECK(IsSupervisedAccountId(account_id) ||
            HasPendingBootstrap(account_id));
     // Special case, removing partially-constructed supervised user or
     // boostrapping user during user list loading.
     ListPrefUpdate users_update(GetLocalState(), kRegularUsers);
     users_update->Remove(base::Value(account_id.GetUserEmail()), nullptr);
     OnUserRemoved(account_id);
   } else {
     NOTREACHED() << "Users are not loaded yet.";
     return;
   }
 
   // Make sure that new data is persisted to Local State.
   GetLocalState()->CommitPendingWrite();
 }
 
 bool UserManagerBase::IsKnownUser(const AccountId& account_id) const {
   return FindUser(account_id) != nullptr;
 }
 
 const User* UserManagerBase::FindUser(const AccountId& account_id) const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   if (active_user_ && active_user_->GetAccountId() == account_id)
     return active_user_;
   return FindUserInList(account_id);
 }
 
 User* UserManagerBase::FindUserAndModify(const AccountId& account_id) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   if (active_user_ && active_user_->GetAccountId() == account_id)
     return active_user_;
   return FindUserInListAndModify(account_id);
 }
 
 const User* UserManagerBase::GetActiveUser() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return active_user_;
 }
 
 User* UserManagerBase::GetActiveUser() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return active_user_;
 }
 
 const User* UserManagerBase::GetPrimaryUser() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return primary_user_;
 }
 
 void UserManagerBase::SaveUserOAuthStatus(
     const AccountId& account_id,
     User::OAuthTokenStatus oauth_token_status) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
 
   DVLOG(1) << "Saving user OAuth token status in Local State";
   User* user = FindUserAndModify(account_id);
   if (user)
     user->set_oauth_token_status(oauth_token_status);
 
   // Do not update local state if data stored or cached outside the user's
   // cryptohome is to be treated as ephemeral.
   if (IsUserNonCryptohomeDataEphemeral(account_id))
     return;
 
   {
     DictionaryPrefUpdate oauth_status_update(GetLocalState(),
                                              kUserOAuthTokenStatus);
     oauth_status_update->SetIntegerWithoutPathExpansion(
         account_id.GetUserEmail(), static_cast<int>(oauth_token_status));
   }
   GetLocalState()->CommitPendingWrite();
 }
 
 void UserManagerBase::SaveForceOnlineSignin(const AccountId& account_id,
                                             bool force_online_signin) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
 
   // Do not update local state if data stored or cached outside the user's
   // cryptohome is to be treated as ephemeral.
   if (IsUserNonCryptohomeDataEphemeral(account_id))
     return;
 
   {
     DictionaryPrefUpdate force_online_update(GetLocalState(),
                                              kUserForceOnlineSignin);
     force_online_update->SetBooleanWithoutPathExpansion(
         account_id.GetUserEmail(), force_online_signin);
   }
   GetLocalState()->CommitPendingWrite();
 }
 
 void UserManagerBase::SaveUserDisplayName(const AccountId& account_id,
                                           const base::string16& display_name) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
 
   if (User* user = FindUserAndModify(account_id)) {
     user->set_display_name(display_name);
 
     // Do not update local state if data stored or cached outside the user's
     // cryptohome is to be treated as ephemeral.
     if (!IsUserNonCryptohomeDataEphemeral(account_id)) {
       DictionaryPrefUpdate display_name_update(GetLocalState(),
                                                kUserDisplayName);
       display_name_update->SetStringWithoutPathExpansion(
           account_id.GetUserEmail(), display_name);
     }
   }
 }
 
 base::string16 UserManagerBase::GetUserDisplayName(
     const AccountId& account_id) const {
   const User* user = FindUser(account_id);
   return user ? user->display_name() : base::string16();
 }
 
 void UserManagerBase::SaveUserDisplayEmail(const AccountId& account_id,
                                            const std::string& display_email) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
 
   User* user = FindUserAndModify(account_id);
   if (!user) {
     LOG(ERROR) << "User not found: " << account_id.GetUserEmail();
     return;  // Ignore if there is no such user.
   }
 
   user->set_display_email(display_email);
 
   // Do not update local state if data stored or cached outside the user's
   // cryptohome is to be treated as ephemeral.
   if (IsUserNonCryptohomeDataEphemeral(account_id))
     return;
 
   DictionaryPrefUpdate display_email_update(GetLocalState(), kUserDisplayEmail);
   display_email_update->SetStringWithoutPathExpansion(account_id.GetUserEmail(),
                                                       display_email);
 }
 
 std::string UserManagerBase::GetUserDisplayEmail(
     const AccountId& account_id) const {
   const User* user = FindUser(account_id);
   return user ? user->display_email() : account_id.GetUserEmail();
 }
 
 void UserManagerBase::SaveUserType(const AccountId& account_id,
                                    const UserType& user_type) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
 
   User* user = FindUserAndModify(account_id);
   if (!user) {
     LOG(ERROR) << "User not found: " << account_id.GetUserEmail();
     return;  // Ignore if there is no such user.
   }
 
   // Do not update local state if data stored or cached outside the user's
   // cryptohome is to be treated as ephemeral.
   if (IsUserNonCryptohomeDataEphemeral(account_id))
     return;
 
   DictionaryPrefUpdate user_type_update(GetLocalState(), kUserType);
   user_type_update->SetIntegerWithoutPathExpansion(account_id.GetUserEmail(),
                                                    static_cast<int>(user_type));
   GetLocalState()->CommitPendingWrite();
 }
 
 void UserManagerBase::UpdateUserAccountData(
     const AccountId& account_id,
     const UserAccountData& account_data) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
 
   SaveUserDisplayName(account_id, account_data.display_name());
 
   if (User* user = FindUserAndModify(account_id)) {
     base::string16 given_name = account_data.given_name();
     user->set_given_name(given_name);
     if (!IsUserNonCryptohomeDataEphemeral(account_id)) {
       DictionaryPrefUpdate given_name_update(GetLocalState(), kUserGivenName);
       given_name_update->SetStringWithoutPathExpansion(
           account_id.GetUserEmail(), given_name);
@@ skipping 22 matching lines @@
     if (existing_users.find(account_id) != existing_users.end() ||
         !users_set->insert(account_id).second) {
       LOG(ERROR) << "Duplicate user: " << email;
       continue;
     }
     users_vector->push_back(account_id);
   }
 }
 
 bool UserManagerBase::IsCurrentUserOwner() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return !owner_account_id_.empty() && active_user_ &&
          active_user_->GetAccountId() == owner_account_id_;
 }
 
 bool UserManagerBase::IsCurrentUserNew() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return is_current_user_new_;
 }
 
 bool UserManagerBase::IsCurrentUserNonCryptohomeDataEphemeral() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() &&
          IsUserNonCryptohomeDataEphemeral(GetActiveUser()->GetAccountId());
 }
 
 bool UserManagerBase::IsCurrentUserCryptohomeDataEphemeral() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() &&
          IsUserCryptohomeDataEphemeral(GetActiveUser()->GetAccountId());
 }
 
 bool UserManagerBase::CanCurrentUserLock() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() && active_user_->can_lock();
 }
 
 bool UserManagerBase::IsUserLoggedIn() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return active_user_;
 }
 
 bool UserManagerBase::IsLoggedInAsUserWithGaiaAccount() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() && active_user_->HasGaiaAccount();
 }
 
 bool UserManagerBase::IsLoggedInAsChildUser() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() && active_user_->GetType() == USER_TYPE_CHILD;
 }
 
 bool UserManagerBase::IsLoggedInAsPublicAccount() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() &&
          active_user_->GetType() == USER_TYPE_PUBLIC_ACCOUNT;
 }
 
 bool UserManagerBase::IsLoggedInAsGuest() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() && active_user_->GetType() == USER_TYPE_GUEST;
 }
 
 bool UserManagerBase::IsLoggedInAsSupervisedUser() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() && active_user_->GetType() == USER_TYPE_SUPERVISED;
 }
 
 bool UserManagerBase::IsLoggedInAsKioskApp() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() && active_user_->GetType() == USER_TYPE_KIOSK_APP;
 }
 
 bool UserManagerBase::IsLoggedInAsArcKioskApp() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() && active_user_->GetType() == USER_TYPE_ARC_KIOSK_APP;
 }
 
 bool UserManagerBase::IsLoggedInAsStub() const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   return IsUserLoggedIn() && IsStubAccountId(active_user_->GetAccountId());
 }
 
 bool UserManagerBase::IsUserNonCryptohomeDataEphemeral(
     const AccountId& account_id) const {
   // Data belonging to the guest and stub users is always ephemeral.
   if (IsGuestAccountId(account_id) || IsStubAccountId(account_id))
     return true;
 
   // Data belonging to the owner, anyone found on the user list and obsolete
@@ skipping 41 matching lines @@
   if (AreEphemeralUsersEnabled() && user &&
       user->GetType() == USER_TYPE_REGULAR &&
       FindUserInList(account_id) == nullptr) {
     return true;
   }
 
   return false;
 }
 
 void UserManagerBase::AddObserver(UserManager::Observer* obs) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   observer_list_.AddObserver(obs);
 }
 
 void UserManagerBase::RemoveObserver(UserManager::Observer* obs) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   observer_list_.RemoveObserver(obs);
 }
 
 void UserManagerBase::AddSessionStateObserver(
     UserManager::UserSessionStateObserver* obs) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   session_state_observer_list_.AddObserver(obs);
 }
 
 void UserManagerBase::RemoveSessionStateObserver(
     UserManager::UserSessionStateObserver* obs) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   session_state_observer_list_.RemoveObserver(obs);
 }
 
 void UserManagerBase::NotifyLocalStateChanged() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   for (auto& observer : observer_list_)
     observer.LocalStateChanged(this);
 }
 
 void UserManagerBase::NotifyUserImageChanged(const User& user) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   for (auto& observer : observer_list_)
     observer.OnUserImageChanged(user);
 }
 
 void UserManagerBase::NotifyUserProfileImageUpdateFailed(const User& user) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   for (auto& observer : observer_list_)
     observer.OnUserProfileImageUpdateFailed(user);
 }
 
 void UserManagerBase::NotifyUserProfileImageUpdated(
     const User& user,
     const gfx::ImageSkia& profile_image) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   for (auto& observer : observer_list_)
     observer.OnUserProfileImageUpdated(user, profile_image);
 }
 
 bool UserManagerBase::CanUserBeRemoved(const User* user) const {
   // Only regular and supervised users are allowed to be manually removed.
   if (!user ||
       !(user->HasGaiaAccount() || user->IsSupervised() ||
         user->IsActiveDirectoryUser()))
     return false;
@@ skipping 41 matching lines @@
 
 const AccountId& UserManagerBase::GetPendingUserSwitchID() const {
   return pending_user_switch_;
 }
 
 void UserManagerBase::SetPendingUserSwitchId(const AccountId& account_id) {
   pending_user_switch_ = account_id;
 }
 
 void UserManagerBase::EnsureUsersLoaded() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   if (!GetLocalState())
     return;
 
   if (user_loading_stage_ != STAGE_NOT_LOADED)
     return;
   user_loading_stage_ = STAGE_LOADING;
 
   PerformPreUserListLoadingActions();
 
   PrefService* local_state = GetLocalState();
@@ skipping 90 matching lines @@
 User* UserManagerBase::FindUserInListAndModify(const AccountId& account_id) {
   UserList& users = GetUsersAndModify();
   for (UserList::iterator it = users.begin(); it != users.end(); ++it) {
     if ((*it)->GetAccountId() == account_id)
       return *it;
   }
   return nullptr;
 }
 
 void UserManagerBase::GuestUserLoggedIn() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   active_user_ = User::CreateGuestUser(GetGuestAccountId());
 }
 
 void UserManagerBase::AddUserRecord(User* user) {
   // Add the user to the front of the user list.
   ListPrefUpdate prefs_users_update(GetLocalState(), kRegularUsers);
   prefs_users_update->Insert(
       0, base::MakeUnique<base::Value>(user->GetAccountId().GetUserEmail()));
   users_.insert(users_.begin(), user);
 }
@@ skipping 14 matching lines @@
   }
 
   AddUserRecord(active_user_);
 
   // Make sure that new data is persisted to Local State.
   GetLocalState()->CommitPendingWrite();
 }
 
 void UserManagerBase::RegularUserLoggedInAsEphemeral(
     const AccountId& account_id) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   SetIsCurrentUserNew(true);
   is_current_user_ephemeral_regular_user_ = true;
   active_user_ = User::CreateRegularUser(account_id);
 }
 
 void UserManagerBase::NotifyOnLogin() {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
 
   NotifyActiveUserHashChanged(active_user_->username_hash());
   NotifyActiveUserChanged(active_user_);
   CallUpdateLoginState();
 }
 
 User::OAuthTokenStatus UserManagerBase::LoadUserOAuthStatus(
     const AccountId& account_id) const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
 
   const base::DictionaryValue* prefs_oauth_status =
       GetLocalState()->GetDictionary(kUserOAuthTokenStatus);
   int oauth_token_status = User::OAUTH_TOKEN_STATUS_UNKNOWN;
   if (prefs_oauth_status &&
       prefs_oauth_status->GetIntegerWithoutPathExpansion(
           account_id.GetUserEmail(), &oauth_token_status)) {
     User::OAuthTokenStatus status =
         static_cast<User::OAuthTokenStatus>(oauth_token_status);
     HandleUserOAuthTokenStatusChange(account_id, status);
 
     return status;
   }
   return User::OAUTH_TOKEN_STATUS_UNKNOWN;
 }
 
 bool UserManagerBase::LoadForceOnlineSignin(const AccountId& account_id) const {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
 
   const base::DictionaryValue* prefs_force_online =
       GetLocalState()->GetDictionary(kUserForceOnlineSignin);
   bool force_online_signin = false;
   if (prefs_force_online) {
     prefs_force_online->GetBooleanWithoutPathExpansion(
         account_id.GetUserEmail(), &force_online_signin);
   }
   return force_online_signin;
 }
@@ skipping 44 matching lines @@
         prefs_users_update->AppendString(user_email);
       }
       ++it;
     }
   }
   OnUserRemoved(account_id);
   return user;
 }
 
 void UserManagerBase::NotifyActiveUserChanged(const User* active_user) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   for (auto& observer : session_state_observer_list_)
     observer.ActiveUserChanged(active_user);
 }
 
 void UserManagerBase::NotifyUserAddedToSession(const User* added_user,
                                                bool user_switch_pending) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   for (auto& observer : session_state_observer_list_)
     observer.UserAddedToSession(added_user);
 }
 
 void UserManagerBase::NotifyActiveUserHashChanged(const std::string& hash) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   for (auto& observer : session_state_observer_list_)
     observer.ActiveUserHashChanged(hash);
 }
 
 void UserManagerBase::ChangeUserChildStatus(User* user, bool is_child) {
-  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(!task_runner_ || task_runner_->RunsTasksOnCurrentThread());
   if (user->IsSupervised() == is_child)
     return;
   user->SetIsChild(is_child);
   SaveUserType(user->GetAccountId(), is_child
                                          ? user_manager::USER_TYPE_CHILD
                                          : user_manager::USER_TYPE_REGULAR);
   for (auto& observer : session_state_observer_list_)
     observer.UserChangedChildStatus(user);
 }
 
@@ skipping 64 matching lines @@
 }
 
 void UserManagerBase::DeleteUser(User* user) {
   const bool is_active_user = (user == active_user_);
   delete user;
   if (is_active_user)
     active_user_ = nullptr;
 }
 
 }  // namespace user_manager