Turning on MultiProfile by default for ChromeOS

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 "ash/multi_profile_uma.h"
@@ skipping 34 matching lines @@
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/profiles/multiprofiles_session_aborted_dialog.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/session_length_limiter.h"
 #include "chrome/browser/managed_mode/chromeos/managed_user_password_service_factory.h"
 #include "chrome/browser/managed_mode/chromeos/manager_password_service_factory.h"
 #include "chrome/browser/net/nss_context.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/crash_keys.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/cert_loader.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
@@ skipping 216 matching lines @@
     device_local_account_policy_service_->RemoveObserver(this);
 
   for (UserImageManagerMap::iterator it = user_image_managers_.begin(),
                                      ie = user_image_managers_.end();
        it != ie; ++it) {
     it->second->Shutdown();
   }
   multi_profile_user_controller_.reset();
   avatar_policy_observer_.reset();
   wallpaper_policy_observer_.reset();
+  registrar_.RemoveAll();
 }
 
 MultiProfileUserController* UserManagerImpl::GetMultiProfileUserController() {
   return multi_profile_user_controller_.get();
 }
 
 UserImageManager* UserManagerImpl::GetUserImageManager(
     const std::string& user_id) {
   UserImageManagerMap::iterator ui = user_image_managers_.find(user_id);
   if (ui != user_image_managers_.end())
     return ui->second.get();
   linked_ptr<UserImageManagerImpl> mgr(new UserImageManagerImpl(user_id, this));
   user_image_managers_[user_id] = mgr;
   return mgr.get();
 }
 
 SupervisedUserManager* UserManagerImpl::GetSupervisedUserManager() {
   return supervised_user_manager_.get();
 }
 
 const UserList& UserManagerImpl::GetUsers() const {
   const_cast<UserManagerImpl*>(this)->EnsureUsersLoaded();
   return users_;
 }
 
 UserList UserManagerImpl::GetUsersAdmittedForMultiProfile() const {
-  if (!UserManager::IsMultipleProfilesAllowed())
-    return UserList();
-
   // Supervised users are not allowed to use multi profile.
   if (logged_in_users_.size() == 1 &&
       GetPrimaryUser()->GetType() != User::USER_TYPE_REGULAR)
     return UserList();
 
   UserList result;
   int num_users_allowed = 0;
   const UserList& users = GetUsers();
   for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
     if ((*it)->GetType() == User::USER_TYPE_REGULAR && !(*it)->is_logged_in()) {
@@ skipping 78 matching lines @@
 
 const std::string& UserManagerImpl::GetOwnerEmail() {
   return owner_email_;
 }
 
 void UserManagerImpl::UserLoggedIn(const std::string& user_id,
                                    const std::string& username_hash,
                                    bool browser_restart) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(::switches::kMultiProfiles))
-    DCHECK(!IsUserLoggedIn());
-
   User* user = FindUserInListAndModify(user_id);
   if (active_user_ && user) {
     user->set_is_logged_in(true);
     user->set_username_hash(username_hash);
     logged_in_users_.push_back(user);
     lru_logged_in_users_.push_back(user);
     // Reset the new user flag if the user already exists.
     is_current_user_new_ = false;
     NotifyUserAddedToSession(user);
     // Remember that we need to switch to this user as soon as profile ready.
@@ skipping 55 matching lines @@
   UMA_HISTOGRAM_ENUMERATION("UserManager.LoginUserType",
                             active_user_->GetType(), User::NUM_USER_TYPES);
 
   g_browser_process->local_state()->SetString(kLastLoggedInRegularUser,
     (active_user_->GetType() == User::USER_TYPE_REGULAR) ? user_id : "");
 
   NotifyOnLogin();
 }
 
 void UserManagerImpl::SwitchActiveUser(const std::string& user_id) {
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(::switches::kMultiProfiles))
-    return;
-
   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()) {
@@ skipping 168 matching lines @@
 const User* UserManagerImpl::GetPrimaryUser() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return primary_user_;
 }
 
 User* UserManagerImpl::GetUserByProfile(Profile* profile) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (ProfileHelper::IsSigninProfile(profile))
     return NULL;
 
-  if (IsMultipleProfilesAllowed()) {
-    const std::string username_hash =
-        ProfileHelper::GetUserIdHashFromProfile(profile);
-    const UserList& users = GetUsers();
-    const UserList::const_iterator pos = std::find_if(
-        users.begin(), users.end(), UserHashMatcher(username_hash));
-    if (pos != users.end())
-      return *pos;
+  // Special case for non-CrOS tests that do create several profiles
+  // and don't really care about mapping to the real user.
+  // Without multi-profiles on Chrome OS such tests always got active_user_.
+  // Now these tests will specify special flag to continue working.
+  // In future those tests can get a proper CrOS configuration i.e. register
+  // and login several users if they want to work with an additional profile.

[Mr4D (OOO till 08-26), 2014/05/14 16:32:40]

It feels rather odd since why should e.g. android/windows/.. specify this flag
instead of the other way around?

Just thinking - could we maybe add something like "--os_chromeos_only_test" to
the test framework which does explicit chrome os testing and all other tests
ignore this?

That all said - it appears that the definition of the flag states that this is
temporary of nature and let's hope we remove it. :)

[zel, 2014/05/14 17:48:39]

Yeah, this flag is not an ideal solution. We should remove it as soon as this CL
lands by cleaning up the real problem behind those tests.

+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kIgnoreUserProfileMappingForTests)) {
+    return active_user_;
+  }
 
-    // Many tests do not have their users registered with UserManager and
-    // runs here. If |active_user_| matches |profile|, returns it.
-    return active_user_ &&
-                   ProfileHelper::GetProfilePathByUserIdHash(
-                       active_user_->username_hash()) == profile->GetPath()
-               ? active_user_
-               : NULL;
-  }
-  return active_user_;
+  const std::string username_hash =
+      ProfileHelper::GetUserIdHashFromProfile(profile);
+  const UserList& users = GetUsers();
+  const UserList::const_iterator pos = std::find_if(
+      users.begin(), users.end(), UserHashMatcher(username_hash));
+  if (pos != users.end())
+    return *pos;
+
+  // Many tests do not have their users registered with UserManager and
+  // runs here. If |active_user_| matches |profile|, returns it.
+  return active_user_ &&
+                 ProfileHelper::GetProfilePathByUserIdHash(
+                     active_user_->username_hash()) == profile->GetPath()
+             ? active_user_
+             : NULL;
 }
 
 Profile* UserManagerImpl::GetProfileByUser(const User* user) const {
   Profile* profile = NULL;
-  if (IsMultipleProfilesAllowed() && user->is_profile_created())
+  if (user->is_profile_created())
     profile = ProfileHelper::GetProfileByUserIdHash(user->username_hash());
   else
     profile = ProfileManager::GetActiveUserProfile();
 
   // GetActiveUserProfile() or GetProfileByUserIdHash() returns a new instance
   // of ProfileImpl(), but actually its OffTheRecordProfile() should be used.
   if (profile && IsLoggedInAsGuest())
     profile = profile->GetOffTheRecordProfile();
   return profile;
 }
@@ skipping 1140 matching lines @@
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   return locally_managed_users_allowed || !connector->IsEnterpriseManaged();
 }
 
 base::FilePath UserManagerImpl::GetUserProfileDir(
     const std::string& user_id) const {
   // TODO(dpolukhin): Remove Chrome OS specific profile path logic from
   // ProfileManager and use only this function to construct profile path.
   // TODO(nkostylev): Cleanup profile dir related code paths crbug.com/294233
   base::FilePath profile_dir;
-  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-  if (command_line.HasSwitch(::switches::kMultiProfiles)) {
-    const User* user = FindUser(user_id);
-    if (user && !user->username_hash().empty())
-      profile_dir = ProfileHelper::GetUserProfileDir(user->username_hash());
-  } else if (command_line.HasSwitch(chromeos::switches::kLoginProfile)) {
-    profile_dir = ProfileHelper::GetProfileDirByLegacyLoginProfileSwitch();
-  } else {
-    // We should never be logged in with no profile dir unless
-    // multi-profiles are enabled.
-    NOTREACHED();
-    profile_dir = base::FilePath();
-  }
+  const User* user = FindUser(user_id);
+  if (user && !user->username_hash().empty())
+    profile_dir = ProfileHelper::GetUserProfileDir(user->username_hash());
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   profile_dir = profile_manager->user_data_dir().Append(profile_dir);
 
   return profile_dir;
 }
 
 UserFlow* UserManagerImpl::GetDefaultUserFlow() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!default_flow_.get())
@@ skipping 204 matching lines @@
 }
 
 void UserManagerImpl::DeleteUser(User* user) {
   const bool is_active_user = (user == active_user_);
   delete user;
   if (is_active_user)
     active_user_ = NULL;
 }
 
 }  // namespace chromeos