ProfileManager doesn't depend on "--login-profile" switch.

chrome/browser/chromeos/profiles/profile_helper.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/profiles/profile_helper.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/chromeos/login/signin/oauth2_login_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chromeos/chromeos_switches.h"
 #include "components/user_manager/user.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace chromeos {
 
 namespace {
 
+// As defined in /chromeos/dbus/cryptohome_client.cc.
+static const char kUserIdHashSuffix[] = "-hash";
+
 bool ShouldAddProfileDirPrefix(const std::string& user_id_hash) {
   // Do not add profile dir prefix for legacy profile dir and test
   // user profile. The reason of not adding prefix for test user profile
   // is to keep the promise that TestingProfile::kTestUserProfileDir and
   // chrome::kTestUserProfileDir are always in sync. Otherwise,
   // TestingProfile::kTestUserProfileDir needs to be dynamically calculated
   // based on whether multi profile is enabled or not.
   return user_id_hash != chrome::kLegacyProfileDir &&
       user_id_hash != chrome::kTestUserProfileDir;
 }
@@ skipping 49 matching lines @@
   // crbug.com/238998
   // TODO(nkostylev): Remove this check once these bugs are fixed.
   DCHECK(!user_id_hash.empty());
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   base::FilePath profile_path = profile_manager->user_data_dir();
 
   return profile_path.Append(GetUserProfileDir(user_id_hash));
 }
 
 // static
-base::FilePath ProfileHelper::GetProfileDirByLegacyLoginProfileSwitch() {
-  const std::string login_profile_value =
-      CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-          chromeos::switches::kLoginProfile);
-  return ProfileHelper::GetUserProfileDir(login_profile_value);
-}
-
-// static
 base::FilePath ProfileHelper::GetSigninProfileDir() {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   base::FilePath user_data_dir = profile_manager->user_data_dir();
   return user_data_dir.AppendASCII(chrome::kInitialProfile);
 }
 
 // static
 Profile* ProfileHelper::GetSigninProfile() {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   return profile_manager->GetProfile(GetSigninProfileDir())->
@@ skipping 18 matching lines @@
     return std::string();
   }
 
   return profile_dir.substr(prefix.length(),
                             profile_dir.length() - prefix.length());
 }
 
 // static
 base::FilePath ProfileHelper::GetUserProfileDir(
     const std::string& user_id_hash) {
-  DCHECK(!user_id_hash.empty());
+  CHECK(!user_id_hash.empty());
   return ShouldAddProfileDirPrefix(user_id_hash)
              ? base::FilePath(chrome::kProfileDirPrefix + user_id_hash)
              : base::FilePath(user_id_hash);
 }
 
 // static
-base::FilePath ProfileHelper::GetUserProfileDirByUserId(
-    const std::string& user_id) {
-  // 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 user_manager::User* user =
-      user_manager::UserManager::Get()->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;
-}
-
-// static
 bool ProfileHelper::IsSigninProfile(Profile* profile) {
   return profile->GetPath().BaseName().value() == chrome::kInitialProfile;
 }
 
 // static
 bool ProfileHelper::IsOwnerProfile(Profile* profile) {
   if (!profile)
     return false;
   user_manager::User* user = ProfileHelper::Get()->GetUserByProfile(profile);
   if (!user)
@@ skipping 120 matching lines @@
          ++it) {
       if ((*it)->email() == user_name)
         return *it;
     }
 
     // In case of test setup we should always default to primary user.
     return const_cast<user_manager::User*>(
         user_manager::UserManager::Get()->GetPrimaryUser());
   }
 
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(!content::BrowserThread::IsThreadInitialized(
+             content::BrowserThread::UI) ||
+         content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (ProfileHelper::IsSigninProfile(profile))
     return NULL;
 
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
 
   // 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
@@ skipping 48 matching lines @@
     login_manager->RemoveObserver(this);
     ClearSigninProfile(base::Closure());
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ProfileHelper, UserManager::UserSessionStateObserver implementation:
 
 void ProfileHelper::ActiveUserHashChanged(const std::string& hash) {
   active_user_id_hash_ = hash;
-  base::FilePath profile_path = GetProfilePathByUserIdHash(hash);
-  VLOG(1) << "Switching to profile path: " << profile_path.value();
 }
 
 void ProfileHelper::SetProfileToUserMappingForTesting(
     user_manager::User* user) {
   user_list_for_testing_.push_back(user);
 }
 
 // static
 void ProfileHelper::SetProfileToUserForTestingEnabled(bool enabled) {
   enable_profile_to_user_testing = enabled;
 }
 
 // static
 void ProfileHelper::SetAlwaysReturnPrimaryUserForTesting(bool value) {
   always_return_primary_user_for_testing = true;
   ProfileHelper::SetProfileToUserForTestingEnabled(true);
 }
 
 void ProfileHelper::SetUserToProfileMappingForTesting(
     const user_manager::User* user,
     Profile* profile) {
   user_to_profile_for_testing_[user] = profile;
 }
 
+// static
+std::string ProfileHelper::GetUserIdHashByUserIdForTesting(
+    const std::string& user_id) {
+  return user_id + kUserIdHashSuffix;
+}
+
 }  // namespace chromeos