CrOS multi-profiles ProfileManager changes

chrome/browser/profiles/profile_manager.cc

 // Copyright (c) 2012 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/profiles/profile_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 49 matching lines @@
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/startup/startup_browser_creator.h"
 #endif  // !defined (OS_IOS)
 
 #if defined(OS_WIN)
 #include "base/win/metro.h"
 #include "chrome/installer/util/browser_distribution.h"
 #endif
 
 #if defined(OS_CHROMEOS)
+#include "base/chromeos/chromeos_version.h"
+#include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #endif
 
 using content::BrowserThread;
 using content::UserMetricsAction;
 
 namespace {
@@ skipping 103 matching lines @@
 #if defined(OS_CHROMEOS)
 void CheckCryptohomeIsMounted(chromeos::DBusMethodCallStatus call_status,
                               bool is_mounted) {
   if (call_status != chromeos::DBUS_METHOD_CALL_SUCCESS) {
     LOG(ERROR) << "IsMounted call failed.";
     return;
   }
   if (!is_mounted)
     LOG(ERROR) << "Cryptohome is not mounted.";
 }
+
+// TODO(nkostylev): Remove this hack when http://crbug.com/224291 is fixed.
+// Now user homedirs are mounted to /home/user which is different from
+// user data dir (/home/chronos).
+base::FilePath GetChromeOSProfileDir(const base::FilePath& path) {
+  base::FilePath profile_dir(FILE_PATH_LITERAL("/home/user/"));
+  profile_dir = profile_dir.Append(path);
+  return profile_dir;
+}
 #endif
 
 } // namespace
 
 #if defined(ENABLE_SESSION_SERVICE)
 // static
 void ProfileManager::ShutdownSessionServices() {
   ProfileManager* pm = g_browser_process->profile_manager();
   if (!pm)  // Is NULL when running unit tests.
     return;
@@ skipping 12 matching lines @@
     // Delete both the profile directory and its corresponding cache.
     base::FilePath cache_path;
     chrome::GetUserCacheDirectory(*it, &cache_path);
     file_util::Delete(*it, true);
     file_util::Delete(cache_path, true);
   }
   ProfilesToDelete().clear();
 }
 
 // static
+// TODO(nkostylev): Remove this method once all clients are migrated.
 Profile* ProfileManager::GetDefaultProfile() {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   return profile_manager->GetDefaultProfile(profile_manager->user_data_dir_);
 }
 
 // static
+// TODO(nkostylev): Remove this method once all clients are migrated.
 Profile* ProfileManager::GetDefaultProfileOrOffTheRecord() {
   // TODO (mukai,nkostylev): In the long term we should fix those cases that
   // crash on Guest mode and have only one GetDefaultProfile() method.
   Profile* profile = GetDefaultProfile();
 #if defined(OS_CHROMEOS)
   if (chromeos::UserManager::Get()->IsLoggedInAsGuest())
     profile = profile->GetOffTheRecordProfile();
 #endif
   return profile;
 }
@@ skipping 19 matching lines @@
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
       ALLOW_THIS_IN_INITIALIZER_LIST(
           browser_list_observer_(this)),
 #endif
       closing_all_browsers_(false) {
 #if defined(OS_CHROMEOS)
   registrar_.Add(
       this,
       chrome::NOTIFICATION_LOGIN_USER_CHANGED,
       content::NotificationService::AllSources());
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kMultiProfiles)) {
+    registrar_.Add(
+        this,
+        chrome::NOTIFICATION_ACTIVE_USER_CHANGED,
+        content::NotificationService::AllSources());
+  }
 #endif
   registrar_.Add(
       this,
       chrome::NOTIFICATION_BROWSER_OPENED,
       content::NotificationService::AllSources());
   registrar_.Add(
       this,
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::NotificationService::AllSources());
   registrar_.Add(
       this,
       chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST,
       content::NotificationService::AllSources());
   registrar_.Add(
       this,
       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED,
       content::NotificationService::AllSources());
 
-  if (ProfileShortcutManager::IsFeatureEnabled() && !user_data_dir.empty())
+  if (ProfileShortcutManager::IsFeatureEnabled() && !user_data_dir_.empty())
     profile_shortcut_manager_.reset(ProfileShortcutManager::Create(
                                     this));
 }
 
 ProfileManager::~ProfileManager() {
 }
 
 base::FilePath ProfileManager::GetDefaultProfileDir(
     const base::FilePath& user_data_dir) {
   base::FilePath default_profile_dir(user_data_dir);
@@ skipping 17 matching lines @@
     base::FilePath profile_dir;
     // If the user has logged in, pick up the new profile.
     if (command_line.HasSwitch(chromeos::switches::kLoginProfile)) {
       profile_dir = command_line.GetSwitchValuePath(
           chromeos::switches::kLoginProfile);
     } else {
       // We should never be logged in with no profile dir.
       NOTREACHED();
       return base::FilePath("");
     }
+    // In case of multi-profiles ignore --login-profile switch.
+    // TODO(nkostylev): Some cases like Guest mode will have empty username_hash
+    // so default kLoginProfile dir will be used.
+    if (command_line.HasSwitch(switches::kMultiProfiles) &&
+        !active_profile_username_hash_.empty()) {
+      profile_dir = base::FilePath(active_profile_username_hash_);
+    }
     relative_profile_dir = relative_profile_dir.Append(profile_dir);
     return relative_profile_dir;
   }
 #endif
   // TODO(mirandac): should not automatically be default profile.
   relative_profile_dir =
       relative_profile_dir.AppendASCII(chrome::kInitialProfile);
   return relative_profile_dir;
 }
 
@@ skipping 42 matching lines @@
         }
         to_return.push_back(GetProfile(user_data_dir.AppendASCII(profile)));
       }
     }
   }
   return to_return;
 }
 
 Profile* ProfileManager::GetDefaultProfile(
     const base::FilePath& user_data_dir) {
+#if defined(OS_CHROMEOS)
+  base::FilePath default_profile_dir(user_data_dir);
+  if (logged_in_) {
+    if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kMultiProfiles) &&
+        base::chromeos::IsRunningOnChromeOS()) {
+      // TODO(nkostylev): Change to [user_data_dir]/profile-[hash]
+      default_profile_dir = GetChromeOSProfileDir(GetInitialProfileDir());
+    } else {
+      default_profile_dir = default_profile_dir.Append(GetInitialProfileDir());
+    }
+  } else {
+    default_profile_dir = GetDefaultProfileDir(user_data_dir);
+  }
+#else
   base::FilePath default_profile_dir(user_data_dir);
   default_profile_dir = default_profile_dir.Append(GetInitialProfileDir());
+#endif
 #if defined(OS_CHROMEOS)
   if (!logged_in_) {
     Profile* profile = GetProfile(default_profile_dir);
     // For cros, return the OTR profile so we never accidentally keep
     // user data in an unencrypted profile. But doing this makes
     // many of the browser and ui tests fail. We do return the OTR profile
     // if the login-profile switch is passed so that we can test this.
     // TODO(davemoore) Fix the tests so they allow OTR profiles.
     if (ShouldGoOffTheRecord())
       return profile->GetOffTheRecordProfile();
@@ skipping 100 matching lines @@
 // static
 void ProfileManager::CreateDefaultProfileAsync(const CreateCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   base::FilePath default_profile_dir = profile_manager->user_data_dir_;
   // TODO(mirandac): current directory will not always be default in the future
   default_profile_dir = default_profile_dir.Append(
       profile_manager->GetInitialProfileDir());
 
+#if defined(OS_CHROMEOS)
+  // TODO(nkostylev): Change to [user_data_dir]/profile-[hash]
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kMultiProfiles) &&
+      base::chromeos::IsRunningOnChromeOS()) {
+    default_profile_dir = GetChromeOSProfileDir(
+        profile_manager->GetInitialProfileDir());
+  }
+#endif
+
   // Chrome OS specific note: since we pass string16() here as the icon_url,
   // profile cache information will not get updated with the is_managed value
   // so we're fine with passing all default values here.
   // On Chrome OS |is_managed| preference will get initialized in
   // Profile::CREATE_STATUS_CREATED callback.
   profile_manager->CreateProfileAsync(
       default_profile_dir, callback, string16(), string16(), false);
 }
 
 bool ProfileManager::AddProfile(Profile* profile) {
@@ skipping 63 matching lines @@
 }
 
 void ProfileManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
 #if defined(OS_CHROMEOS)
   if (type == chrome::NOTIFICATION_LOGIN_USER_CHANGED) {
     logged_in_ = true;
 
+    chromeos::User* user = content::Details<chromeos::User>(details).ptr();
+    DCHECK(user);
+
     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
     if (!command_line.HasSwitch(switches::kTestType)) {
       // If we don't have a mounted profile directory we're in trouble.
       // TODO(davemoore) Once we have better api this check should ensure that
       // our profile directory is the one that's mounted, and that it's mounted
       // as the current user.
       chromeos::DBusThreadManager::Get()->GetCryptohomeClient()->IsMounted(
           base::Bind(&CheckCryptohomeIsMounted));
 
       // Confirm that we hadn't loaded the new profile previously.
-      base::FilePath default_profile_dir =
-          user_data_dir_.Append(GetInitialProfileDir());
+      if (command_line.HasSwitch(switches::kMultiProfiles)) {
+        // TODO(nkostylev): We could not enforce username_hash not being
+        // empty here till all cases like Guest mode are migrated.
+        active_profile_username_hash_ = user->username_hash();
+        LOG(INFO) << "Switching to custom profile_dir: "
+                  << active_profile_username_hash_;
+      }
+      base::FilePath default_profile_dir = user_data_dir_.Append(
+          GetInitialProfileDir(/*active_profile_username_hash_*/));

[sail, 2013/04/12 17:28:34]

what's active_profile_username_hash_ here for?

       CHECK(!GetProfileByPath(default_profile_dir))
           << "The default profile was loaded before we mounted the cryptohome.";
     }
     return;
+  } else if (type == chrome::NOTIFICATION_ACTIVE_USER_CHANGED) {
+    chromeos::User* user = content::Details<chromeos::User>(details).ptr();
+    active_profile_username_hash_ = user->username_hash();
+    LOG(INFO) << "Switching to custom profile_dir: "
+              << active_profile_username_hash_;
+    return;
   }
 #endif
   bool save_active_profiles = false;
   switch (type) {
     case chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST: {
       // Ignore any browsers closing from now on.
       closing_all_browsers_ = true;
       break;
     }
     case chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED: {
@@ skipping 506 matching lines @@
 ProfileManager::ProfileInfo::ProfileInfo(
     Profile* profile,
     bool created)
     : profile(profile),
       created(created) {
 }
 
 ProfileManager::ProfileInfo::~ProfileInfo() {
   ProfileDestroyer::DestroyProfileWhenAppropriate(profile.release());
 }