Mark supervised profiles as such immediately when they're created.

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 533 matching lines @@
   // Make sure that we're not loading a profile with the same ID as a profile
   // that's already loaded.
   if (GetProfileByPath(profile->GetPath())) {
     NOTREACHED() << "Attempted to add profile with the same path (" <<
                     profile->GetPath().value() <<
                     ") as an already-loaded profile.";
     return false;
   }
 
   RegisterProfile(profile, true);
+  InitProfileUserPrefs(profile);

[rpetterson, 2013/10/01 20:19:57]

It doesn't really change the call flow, so I'm curious why you moved this up
here?

[Bernhard Bauer, 2013/10/01 20:42:15]

InitProfileUserPrefs() is where we mark a profile as managed when it is
initially created. I need to run this before the BrowserContextKeyedServices are
created, because some of them might do their initialization differently for a
managed profile. I updated the CL description to (hopefully) make that a bit
clearer.

[rpetterson, 2013/10/07 23:22:49]

I understand better what's going on now. However, I don't think managed mode is
the only type of profile creation which uses a delegate so how will this affect
other profile creation flows? If it won't, perhaps it would be simpler to bump
up InitProfileUserPrefs to just before the browser services creation for
everyone.

[Bernhard Bauer, 2013/10/08 14:56:01]

This CL actually does change the behavior for everyone, it's just that
supervised user creation is the rationale behind it, so that's what I mentioned
in the description.

Or are you refering to moving it to another place closer to browser services
creation?

[rpetterson, 2013/10/08 18:02:55]

Yes. If we're changing it for everyone, there should be just one path. With this
CL, you can init the prefs either in OnPrefsLoaded via the delegate or in
AddProfile. We should eliminate the use of the delegate in this case and just
call InitProfileUserPrefs right before browser services creation (like
ProfileImpl::785). Perhaps make that function static or move it to the profile?

   DoFinalInit(profile, ShouldGoOffTheRecord(profile));
   return true;
 }
 
 ProfileManager::ProfileInfo* ProfileManager::RegisterProfile(
     Profile* profile,
     bool created) {
   ProfileInfo* info = new ProfileInfo(profile, created);
   profiles_info_.insert(
       std::make_pair(profile->GetPath(), linked_ptr<ProfileInfo>(info)));
@@ skipping 143 matching lines @@
   // Only keep track of profiles that we are managing; tests may create others.
   if (profile_manager_->profiles_info_.find(
       last_active->GetPath()) != profile_manager_->profiles_info_.end()) {
     local_state->SetString(prefs::kProfileLastUsed,
                            last_active->GetPath().BaseName().MaybeAsASCII());
   }
 }
 #endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 
 void ProfileManager::DoFinalInit(Profile* profile, bool go_off_the_record) {
-  InitProfileUserPrefs(profile);
   DoFinalInitForServices(profile, go_off_the_record);
   AddProfileToCache(profile);
   DoFinalInitLogging(profile);
 
   ProfileMetrics::LogNumberOfProfiles(this);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_ADDED,
       content::Source<Profile>(profile),
       content::NotificationService::NoDetails());
 }
@@ skipping 70 matching lines @@
   return Profile::CreateProfile(path, NULL, Profile::CREATE_MODE_SYNCHRONOUS);
 }
 
 Profile* ProfileManager::CreateProfileAsyncHelper(const base::FilePath& path,
                                                   Delegate* delegate) {
   return Profile::CreateProfile(path,
                                 delegate,
                                 Profile::CREATE_MODE_ASYNCHRONOUS);
 }
 
+void ProfileManager::OnPrefsLoaded(Profile* profile) {
+  InitProfileUserPrefs(profile);
+}
+
 void ProfileManager::OnProfileCreated(Profile* profile,
                                       bool success,
                                       bool is_new_profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ProfilesInfoMap::iterator iter = profiles_info_.find(profile->GetPath());
   DCHECK(iter != profiles_info_.end());
   ProfileInfo* info = iter->second.get();
 
   std::vector<CreateCallback> callbacks;
@@ skipping 171 matching lines @@
       profile_name = UTF16ToUTF8(cache.ChooseNameForNewProfile(avatar_index));
     }
   }
 
   if (!profile->GetPrefs()->HasPrefPath(prefs::kProfileAvatarIndex))
     profile->GetPrefs()->SetInteger(prefs::kProfileAvatarIndex, avatar_index);
 
   if (!profile->GetPrefs()->HasPrefPath(prefs::kProfileName))
     profile->GetPrefs()->SetString(prefs::kProfileName, profile_name);
 
-  if (!profile->GetPrefs()->HasPrefPath(prefs::kManagedUserId))
+  if (!profile->GetPrefs()->HasPrefPath(prefs::kManagedUserId)) {
+    if (managed_user_id.empty() &&
+        CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kNewProfileIsSupervised)) {
+      managed_user_id = "Test ID";
+    }
     profile->GetPrefs()->SetString(prefs::kManagedUserId, managed_user_id);
+  }
 }
 
 void ProfileManager::SetGuestProfilePrefs(Profile* profile) {
   IncognitoModePrefs::SetAvailability(profile->GetPrefs(),
                                       IncognitoModePrefs::FORCED);
   profile->GetPrefs()->SetBoolean(prefs::kShowBookmarkBar, false);
 }
 
 bool ProfileManager::ShouldGoOffTheRecord(Profile* profile) {
   bool go_off_the_record = false;
@@ skipping 166 matching lines @@
 ProfileManager::ProfileInfo::ProfileInfo(
     Profile* profile,
     bool created)
     : profile(profile),
       created(created) {
 }
 
 ProfileManager::ProfileInfo::~ProfileInfo() {
   ProfileDestroyer::DestroyProfileWhenAppropriate(profile.release());
 }