Disable multi-profile UI in managed mode.

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 <set>
 
 #include "chrome/browser/profiles/profile_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 660 matching lines @@
   // Invoke INITIALIZED or FAIL for all profiles.
   RunCallbacks(callbacks, profile,
                profile ? Profile::CREATE_STATUS_INITIALIZED :
                          Profile::CREATE_STATUS_FAIL);
 }
 
 FilePath ProfileManager::GenerateNextProfileDirectoryPath() {
   PrefService* local_state = g_browser_process->local_state();
   DCHECK(local_state);
 
+  DCHECK(!local_state->GetBoolean(prefs::kInManagedMode));
+
   // Create the next profile in the next available directory slot.
   int next_directory = local_state->GetInteger(prefs::kProfilesNumCreated);
   std::string profile_name = chrome::kMultiProfileDirPrefix;
   profile_name.append(base::IntToString(next_directory));
   FilePath new_path = user_data_dir_;
 #if defined(OS_WIN)
   new_path = new_path.Append(ASCIIToUTF16(profile_name));
 #else
   new_path = new_path.Append(profile_name);
 #endif
@@ skipping 11 matching lines @@
 
   profile_manager->CreateProfileAsync(new_path,
                                       base::Bind(&OnOpenWindowForNewProfile));
 }
 
 // static
 void ProfileManager::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterStringPref(prefs::kProfileLastUsed, "");
   prefs->RegisterIntegerPref(prefs::kProfilesNumCreated, 1);
   prefs->RegisterListPref(prefs::kProfilesLastActive);
+  prefs->RegisterBooleanPref(prefs::kInManagedMode, false);
 }
 
 size_t ProfileManager::GetNumberOfProfiles() {
   return GetProfileInfoCache().GetNumberOfProfiles();
 }
 
 bool ProfileManager::CompareProfilePathAndName(
     const ProfileManager::ProfilePathAndName& pair1,
     const ProfileManager::ProfilePathAndName& pair2) {
   int name_compare = pair1.second.compare(pair2.second);
@@ skipping 107 matching lines @@
   if (!logged_in_ &&
       (!command_line.HasSwitch(switches::kTestType) ||
        command_line.HasSwitch(switches::kLoginProfile))) {
     go_off_the_record = true;
   }
 #endif
   return go_off_the_record;
 }
 
 void ProfileManager::ScheduleProfileForDeletion(const FilePath& profile_dir) {
+  PrefService* local_state = g_browser_process->local_state();
+  DCHECK(!local_state->GetBoolean(prefs::kInManagedMode));
+
   // If we're deleting the last profile, then create a new profile in its
   // place.
   ProfileInfoCache& cache = GetProfileInfoCache();
   if (cache.GetNumberOfProfiles() == 1) {
     FilePath new_path = GenerateNextProfileDirectoryPath();
 
     CreateProfileAsync(new_path, base::Bind(&OnOpenWindowForNewProfile));
   }
 
   // Update the last used profile pref before closing browser windows. This way
   // the correct last used profile is set for any notification observers.
-  PrefService* local_state = g_browser_process->local_state();
   std::string last_profile = local_state->GetString(prefs::kProfileLastUsed);
   if (profile_dir.BaseName().MaybeAsASCII() == last_profile) {
     for (size_t i = 0; i < cache.GetNumberOfProfiles(); ++i) {
       FilePath cur_path = cache.GetPathOfProfileAtIndex(i);
       if (cur_path != profile_dir) {
         local_state->SetString(
             prefs::kProfileLastUsed, cur_path.BaseName().MaybeAsASCII());
         break;
       }
     }
@@ skipping 44 matching lines @@
                                       ProfileMetrics::STARTUP_PROFILE_EVENT);
 }
 
 ProfileManagerWithoutInit::ProfileManagerWithoutInit(
     const FilePath& user_data_dir) : ProfileManager(user_data_dir) {
 }
 
 void ProfileManager::RegisterTestingProfile(Profile* profile,
                                             bool add_to_cache) {
   RegisterProfile(profile, true);
-  if (add_to_cache){
+  if (add_to_cache) {
     InitProfileUserPrefs(profile);
     AddProfileToCache(profile);
   }
 }
 
 void ProfileManager::RunCallbacks(const std::vector<CreateCallback>& callbacks,
                                   Profile* profile,
                                   Profile::CreateStatus status) {
   for (size_t i = 0; i < callbacks.size(); ++i)
     callbacks[i].Run(profile, status);
 }