Refactor ProfileInfoCache in c/b/profiles

chrome/browser/profiles/profile_impl.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_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 44 matching lines @@
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/policy/schema_registry_service.h"
 #include "chrome/browser/policy/schema_registry_service_factory.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/prefs/chrome_pref_service_factory.h"
 #include "chrome/browser/prefs/pref_service_syncable_util.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/bookmark_model_loaded_observer.h"
 #include "chrome/browser/profiles/chrome_version_service.h"
 #include "chrome/browser/profiles/gaia_info_update_service_factory.h"
+#include "chrome/browser/profiles/profile_attributes_entry.h"
+#include "chrome/browser/profiles/profile_attributes_storage.h"
 #include "chrome/browser/profiles/profile_destroyer.h"
-#include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_metrics.h"
 #include "chrome/browser/push_messaging/push_messaging_service_factory.h"
 #include "chrome/browser/push_messaging/push_messaging_service_impl.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/signin_ui_util.h"
 #include "chrome/browser/ssl/chrome_ssl_host_state_delegate.h"
 #include "chrome/browser/ssl/chrome_ssl_host_state_delegate_factory.h"
@@ skipping 401 matching lines @@
 }
 
 void ProfileImpl::DoFinalInit() {
   TRACE_EVENT0("browser", "ProfileImpl::DoFinalInit")
   SCOPED_UMA_HISTOGRAM_TIMER("Profile.ProfileImplDoFinalInit");
 
   PrefService* prefs = GetPrefs();
   pref_change_registrar_.Init(prefs);
   pref_change_registrar_.Add(
       prefs::kSupervisedUserId,
-      base::Bind(&ProfileImpl::UpdateProfileSupervisedUserIdCache,
+      base::Bind(&ProfileImpl::UpdateSupervisedUserIdInStorage,
                  base::Unretained(this)));
 
   // Changes in the profile avatar.
   pref_change_registrar_.Add(
       prefs::kProfileAvatarIndex,
-      base::Bind(&ProfileImpl::UpdateProfileAvatarCache,
+      base::Bind(&ProfileImpl::UpdateAvatarInStorage,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kProfileUsingDefaultAvatar,
-      base::Bind(&ProfileImpl::UpdateProfileAvatarCache,
+      base::Bind(&ProfileImpl::UpdateAvatarInStorage,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kProfileUsingGAIAAvatar,
-      base::Bind(&ProfileImpl::UpdateProfileAvatarCache,
+      base::Bind(&ProfileImpl::UpdateAvatarInStorage,
                  base::Unretained(this)));
 
   // Changes in the profile name.
   pref_change_registrar_.Add(
       prefs::kProfileUsingDefaultName,
-      base::Bind(&ProfileImpl::UpdateProfileNameCache,
+      base::Bind(&ProfileImpl::UpdateNameInStorage,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kProfileName,
-      base::Bind(&ProfileImpl::UpdateProfileNameCache,
+      base::Bind(&ProfileImpl::UpdateNameInStorage,
                  base::Unretained(this)));
 
   pref_change_registrar_.Add(
       prefs::kForceEphemeralProfiles,
-      base::Bind(&ProfileImpl::UpdateProfileIsEphemeralCache,
+      base::Bind(&ProfileImpl::UpdateIsEphemeralInStorage,
                  base::Unretained(this)));
 
   // It would be nice to use PathService for fetching this directory, but
   // the cache directory depends on the profile directory, which isn't available
   // to PathService.
   chrome::GetUserCacheDirectory(path_, &base_cache_path_);
   // Always create the cache directory asynchronously.
   scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner =
       JsonPrefStore::GetTaskRunnerForFile(base_cache_path_,
                                           BrowserThread::GetBlockingPool());
   CreateProfileDirectory(sequenced_task_runner.get(), base_cache_path_, false);
 
   // Initialize components that depend on the current value.
-  UpdateProfileSupervisedUserIdCache();
-  UpdateProfileIsEphemeralCache();
+  UpdateSupervisedUserIdInStorage();
+  UpdateIsEphemeralInStorage();
   GAIAInfoUpdateServiceFactory::GetForProfile(this);
 
   PrefService* local_state = g_browser_process->local_state();
   ssl_config_service_manager_.reset(
       ssl_config::SSLConfigServiceManager::CreateDefaultManager(
           local_state,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)));
 
 #if BUILDFLAG(ENABLE_BACKGROUND)
   // Initialize the BackgroundModeManager - this has to be done here before
@@ skipping 620 matching lines @@
 
   if (GetPrefs()->GetBoolean(prefs::kHomePageIsNewTabPage))
     return GURL(chrome::kChromeUINewTabURL);
   GURL home_page(url_formatter::FixupURL(
       GetPrefs()->GetString(prefs::kHomePage), std::string()));
   if (!home_page.is_valid())
     return GURL(chrome::kChromeUINewTabURL);
   return home_page;
 }
 
-void ProfileImpl::UpdateProfileSupervisedUserIdCache() {
+void ProfileImpl::UpdateSupervisedUserIdInStorage() {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
-  size_t index = cache.GetIndexOfProfileWithPath(GetPath());
-  if (index != std::string::npos) {
-    std::string supervised_user_id =
-        GetPrefs()->GetString(prefs::kSupervisedUserId);
-    cache.SetSupervisedUserIdOfProfileAtIndex(index, supervised_user_id);
+  ProfileAttributesEntry* entry;
+  bool has_entry = profile_manager->GetProfileAttributesStorage().
+                       GetProfileAttributesWithPath(GetPath(), &entry);
+  if (has_entry) {
+    entry->SetSupervisedUserId(GetPrefs()->GetString(prefs::kSupervisedUserId));
     ProfileMetrics::UpdateReportedProfilesStatistics(profile_manager);
   }
 }
 
-void ProfileImpl::UpdateProfileNameCache() {
-  ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
-  size_t index = cache.GetIndexOfProfileWithPath(GetPath());
-  if (index != std::string::npos) {
-    std::string profile_name =
-        GetPrefs()->GetString(prefs::kProfileName);
-    cache.SetNameOfProfileAtIndex(index, base::UTF8ToUTF16(profile_name));
-    bool default_name =
-        GetPrefs()->GetBoolean(prefs::kProfileUsingDefaultName);
-    cache.SetProfileIsUsingDefaultNameAtIndex(index, default_name);
+void ProfileImpl::UpdateNameInStorage() {
+  ProfileAttributesEntry* entry;
+  bool has_entry =
+      g_browser_process->profile_manager()->GetProfileAttributesStorage().
+          GetProfileAttributesWithPath(GetPath(), &entry);
+  if (has_entry) {
+    entry->SetName(
+        base::UTF8ToUTF16(GetPrefs()->GetString(prefs::kProfileName)));
+    entry->SetIsUsingDefaultName(
+        GetPrefs()->GetBoolean(prefs::kProfileUsingDefaultName));
   }
 }
 
-void ProfileImpl::UpdateProfileAvatarCache() {
-  ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
-  size_t index = cache.GetIndexOfProfileWithPath(GetPath());
-  if (index != std::string::npos) {
-    size_t avatar_index =
-        GetPrefs()->GetInteger(prefs::kProfileAvatarIndex);
-    cache.SetAvatarIconOfProfileAtIndex(index, avatar_index);
-    bool default_avatar =
-        GetPrefs()->GetBoolean(prefs::kProfileUsingDefaultAvatar);
-    cache.SetProfileIsUsingDefaultAvatarAtIndex(index, default_avatar);
-    bool gaia_avatar =
-        GetPrefs()->GetBoolean(prefs::kProfileUsingGAIAAvatar);
-    cache.SetIsUsingGAIAPictureOfProfileAtIndex(index, gaia_avatar);
+void ProfileImpl::UpdateAvatarInStorage() {
+  ProfileAttributesEntry* entry;
+  bool has_entry =
+      g_browser_process->profile_manager()->GetProfileAttributesStorage().
+          GetProfileAttributesWithPath(GetPath(), &entry);
+  if (has_entry) {
+    entry->SetAvatarIconIndex(
+        GetPrefs()->GetInteger(prefs::kProfileAvatarIndex));
+    entry->SetIsUsingDefaultAvatar(
+        GetPrefs()->GetBoolean(prefs::kProfileUsingDefaultAvatar));
+    entry->SetIsUsingGAIAPicture(
+        GetPrefs()->GetBoolean(prefs::kProfileUsingGAIAAvatar));
   }
 }
 
-void ProfileImpl::UpdateProfileIsEphemeralCache() {
-  ProfileManager* profile_manager = g_browser_process->profile_manager();
-  ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
-  size_t index = cache.GetIndexOfProfileWithPath(GetPath());
-  if (index != std::string::npos) {
-    bool is_ephemeral = GetPrefs()->GetBoolean(prefs::kForceEphemeralProfiles);
-    cache.SetProfileIsEphemeralAtIndex(index, is_ephemeral);
+void ProfileImpl::UpdateIsEphemeralInStorage() {
+  ProfileAttributesEntry* entry;
+  bool has_entry =
+      g_browser_process->profile_manager()->GetProfileAttributesStorage().
+          GetProfileAttributesWithPath(GetPath(), &entry);
+  if (has_entry) {
+    entry->SetIsEphemeral(
+        GetPrefs()->GetBoolean(prefs::kForceEphemeralProfiles));
   }
 }
 
 // Gets the cache parameters from the command line. If |is_media_context| is
 // set to true then settings for the media context type is what we need,
 // |cache_path| will be set to the user provided path, or will not be touched if
 // there is not an argument. |max_size| will be the user provided value or zero
 // by default.
 void ProfileImpl::GetCacheParameters(bool is_media_context,
                                      base::FilePath* cache_path,
@@ skipping 22 matching lines @@
 ProfileImpl::CreateDomainReliabilityMonitor(PrefService* local_state) {
   domain_reliability::DomainReliabilityService* service =
       domain_reliability::DomainReliabilityServiceFactory::GetInstance()->
           GetForBrowserContext(this);
   if (!service)
     return std::unique_ptr<domain_reliability::DomainReliabilityMonitor>();
 
   return service->CreateMonitor(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
 }