Fix the System Profile with extensions.

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 286 matching lines @@
 // static
 Profile* ProfileManager::GetLastUsedProfile() {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   return profile_manager->GetLastUsedProfile(profile_manager->user_data_dir_);
 }
 
 // static
 Profile* ProfileManager::GetLastUsedProfileAllowedByPolicy() {
   Profile* profile = GetLastUsedProfile();
   if (profile->IsGuestSession() ||
+      profile->IsSystemProfile() ||
       IncognitoModePrefs::GetAvailability(profile->GetPrefs()) ==
       IncognitoModePrefs::FORCED) {
     return profile->GetOffTheRecordProfile();
   }
   return profile;
 }
 
 // static
 std::vector<Profile*> ProfileManager::GetLastOpenedProfiles() {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
@@ skipping 113 matching lines @@
     }
 
     ProfileMetrics::UpdateReportedProfilesStatistics(this);
   }
 
   // Call or enqueue the callback.
   if (!callback.is_null()) {
     if (iter != profiles_info_.end() && info->created) {
       Profile* profile = info->profile.get();
       // If this was the guest profile, apply settings and go OffTheRecord.
-      if (profile->GetPath() == ProfileManager::GetGuestProfilePath()) {
+      // SystemProfile also needs characteristics of being off the record, such

[msw, 2015/05/21 04:34:43]

nit: "The system profile"

[Mike Lerman, 2015/05/21 15:27:31]

Done.

+      // as having no extensions, not writing to disk, etc.
+      if (profile->GetPath() == ProfileManager::GetGuestProfilePath() ||
+          profile->GetPath() == ProfileManager::GetSystemProfilePath()) {

[msw, 2015/05/21 04:34:43]

nit: use profile->IsSystemProfile() instead? (ditto for IsGuestSession() above)
(or maybe this should use ProfileManager::ShouldGoOffTheRecord()?)

[Mike Lerman, 2015/05/21 15:27:31]

This works now, as these items are set during profile_impl's constructor. Done.

         SetGuestProfilePrefs(profile);

[msw, 2015/05/21 04:34:43]

nit: maybe this should be renamed?

[Mike Lerman, 2015/05/21 15:27:30]

I tried "SetNonPersonalProfilePrefs" since the profiles aren't for a single
person or created by any person, they're created by chromium. Up for a better
name :) AutoProfile? SharedOTRProfile? PredefinedProfile? There isn't really a
good word that unifies these.

[msw, 2015/05/21 17:48:11]

SetNonPersonalProfilePrefs sgtm. SetSystemProfilePrefs might also be okay, if
one might consider the Guest Profile a "system profile"...

         profile = profile->GetOffTheRecordProfile();
       }
       // Profile has already been created. Run callback immediately.
       callback.Run(profile, Profile::CREATE_STATUS_INITIALIZED);
     } else {
       // Profile is either already in the process of being created, or new.
       // Add callback to the list.
       info->callbacks.push_back(callback);
     }
   }
@@ skipping 543 matching lines @@
     info->created = true;
   } else {
     profile = NULL;
     profiles_info_.erase(iter);
     // TODO(yiyaoliu): This is temporary, remove it after it's not used.
     UMA_HISTOGRAM_COUNTS_100("UMA.ProfilesCount.AfterErase",
                              profiles_info_.size());
   }
 
   if (profile) {
     // If this was the guest profile, finish setting its special status.

[msw, 2015/05/21 04:34:43]

nit: update comment.

[Mike Lerman, 2015/05/21 15:27:30]

Done.

-    if (profile->GetPath() == ProfileManager::GetGuestProfilePath())
+    if (profile->GetPath() == ProfileManager::GetGuestProfilePath() ||

[msw, 2015/05/21 04:34:43]

ditto nit: use IsSystemProfile() and IsGuestSession() or ShouldGoOffTheRecord()

[Mike Lerman, 2015/05/21 15:27:31]

Done.

+        profile->GetPath() == ProfileManager::GetSystemProfilePath()) {
       SetGuestProfilePrefs(profile);
+    }
 
     // Invoke CREATED callback for incognito profiles.
     if (go_off_the_record)
       RunCallbacks(callbacks, profile, Profile::CREATE_STATUS_CREATED);
   }
 
   // Invoke INITIALIZED or FAIL for all profiles.
   RunCallbacks(callbacks, profile,
                profile ? Profile::CREATE_STATUS_INITIALIZED :
                          Profile::CREATE_STATUS_LOCAL_FAIL);
@@ skipping 304 matching lines @@
         cache.GetIndexOfProfileWithPath(profile->GetPath()), true);
   }
 }
 
 void ProfileManager::SetGuestProfilePrefs(Profile* profile) {
   PrefService* prefs = profile->GetPrefs();
   prefs->SetBoolean(prefs::kSigninAllowed, false);
   prefs->SetBoolean(bookmarks::prefs::kEditBookmarksEnabled, false);
   prefs->SetBoolean(bookmarks::prefs::kShowBookmarkBar, false);
   prefs->ClearPref(DefaultSearchManager::kDefaultSearchProviderDataPrefName);
-  // This can be removed in the future but needs to be present through
-  // a release (or two) so that any existing installs get switched to
-  // the new state and away from the previous "forced" state.
-  IncognitoModePrefs::SetAvailability(prefs, IncognitoModePrefs::ENABLED);
 }
 
 bool ProfileManager::ShouldGoOffTheRecord(Profile* profile) {
 #if defined(OS_CHROMEOS)
   if (profile->GetPath().BaseName().value() == chrome::kInitialProfile) {
     return true;
   }
 #endif
-  return profile->IsGuestSession();
+  return profile->IsGuestSession() || profile->IsSystemProfile();
 }
 
 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);
 }
 
 ProfileManager::ProfileInfo::ProfileInfo(
     Profile* profile,
     bool created)
     : profile(profile),
       created(created) {
 }
 
 ProfileManager::ProfileInfo::~ProfileInfo() {
   ProfileDestroyer::DestroyProfileWhenAppropriate(profile.release());
 }
 
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
 void ProfileManager::UpdateLastUser(Profile* last_active) {
   PrefService* local_state = g_browser_process->local_state();
   DCHECK(local_state);
   // Only keep track of profiles that we are managing; tests may create others.
-  if (profiles_info_.find(last_active->GetPath()) != profiles_info_.end()) {
+  // Also never consider the SystemProfile as "active".
+  if (profiles_info_.find(last_active->GetPath()) != profiles_info_.end() &&
+      !last_active->IsSystemProfile()) {
     std::string profile_path_base =
         last_active->GetPath().BaseName().MaybeAsASCII();
     if (profile_path_base != GetLastUsedProfileName())
       local_state->SetString(prefs::kProfileLastUsed, profile_path_base);
 
     ProfileInfoCache& cache = GetProfileInfoCache();
     size_t profile_index =
         cache.GetIndexOfProfileWithPath(last_active->GetPath());
     if (profile_index != std::string::npos)
       cache.SetProfileActiveTimeAtIndex(profile_index);
@@ skipping 74 matching lines @@
   }
 
   FinishDeletingProfile(profile_to_delete_path, new_active_profile_path);
   if (!original_callback.is_null())
     original_callback.Run(loaded_profile, status);
 }
 
 ProfileManagerWithoutInit::ProfileManagerWithoutInit(
     const base::FilePath& user_data_dir) : ProfileManager(user_data_dir) {
 }