Add gaia_id to ProfileInfoCache.

chrome/browser/profiles/profile_info_cache.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_info_cache.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
@@ skipping 26 matching lines @@
 #endif
 
 using content::BrowserThread;
 
 namespace {
 
 const char kNameKey[] = "name";
 const char kShortcutNameKey[] = "shortcut_name";
 const char kGAIANameKey[] = "gaia_name";
 const char kGAIAGivenNameKey[] = "gaia_given_name";
+const char kGAIAIdKey[] = "gaia_id";
 const char kUserNameKey[] = "user_name";
 const char kIsUsingDefaultNameKey[] = "is_using_default_name";
 const char kIsUsingDefaultAvatarKey[] = "is_using_default_avatar";
 const char kAvatarIconKey[] = "avatar_icon";
 const char kAuthCredentialsKey[] = "local_auth_credentials";
 const char kUseGAIAPictureKey[] = "use_gaia_picture";
 const char kBackgroundAppsKey[] = "background_apps";
 const char kGAIAPictureFileNameKey[] = "gaia_picture_file_name";
 const char kIsOmittedFromProfileListKey[] = "is_omitted_from_profile_list";
 const char kSigninRequiredKey[] = "signin_required";
@@ skipping 133 matching lines @@
   STLDeleteContainerPairSecondPointers(
       cached_avatar_images_.begin(), cached_avatar_images_.end());
   STLDeleteContainerPairSecondPointers(
       avatar_images_downloads_in_progress_.begin(),
       avatar_images_downloads_in_progress_.end());
 }
 
 void ProfileInfoCache::AddProfileToCache(
     const base::FilePath& profile_path,
     const base::string16& name,
-    const base::string16& username,
+    const std::string& gaia_id,
+    const base::string16& user_name,
     size_t icon_index,
     const std::string& supervised_user_id) {
   std::string key = CacheKeyFromProfilePath(profile_path);
   DictionaryPrefUpdate update(prefs_, prefs::kProfileInfoCache);
   base::DictionaryValue* cache = update.Get();
 
   scoped_ptr<base::DictionaryValue> info(new base::DictionaryValue);
   info->SetString(kNameKey, name);
-  info->SetString(kUserNameKey, username);
+  info->SetString(kGAIAIdKey, gaia_id);
+  info->SetString(kUserNameKey, user_name);
   info->SetString(kAvatarIconKey,
       profiles::GetDefaultAvatarIconUrl(icon_index));
   // Default value for whether background apps are running is false.
   info->SetBoolean(kBackgroundAppsKey, false);
   info->SetString(kSupervisedUserId, supervised_user_id);
   info->SetBoolean(kIsOmittedFromProfileListKey, !supervised_user_id.empty());
   info->SetBoolean(kProfileIsEphemeral, false);
   info->SetBoolean(kIsUsingDefaultNameKey, IsDefaultProfileName(name));
   // Assume newly created profiles use a default avatar.
   info->SetBoolean(kIsUsingDefaultAvatarKey, true);
@@ skipping 142 matching lines @@
   return name;
 }
 
 base::string16 ProfileInfoCache::GetGAIAGivenNameOfProfileAtIndex(
     size_t index) const {
   base::string16 name;
   GetInfoForProfileAtIndex(index)->GetString(kGAIAGivenNameKey, &name);
   return name;
 }
 
+std::string ProfileInfoCache::GetGAIAIdOfProfileAtIndex(
+    size_t index) const {
+  std::string gaia_id;
+  GetInfoForProfileAtIndex(index)->GetString(kGAIAIdKey, &gaia_id);
+  return gaia_id;
+}
+
 const gfx::Image* ProfileInfoCache::GetGAIAPictureOfProfileAtIndex(
     size_t index) const {
   base::FilePath path = GetPathOfProfileAtIndex(index);
   std::string key = CacheKeyFromProfilePath(path);
 
   std::string file_name;
   GetInfoForProfileAtIndex(index)->GetString(
       kGAIAPictureFileNameKey, &file_name);
 
   // If the picture is not on disk then return NULL.
@@ skipping 58 matching lines @@
   GetInfoForProfileAtIndex(index)->GetBoolean(kProfileIsEphemeral, &value);
   return value;
 }
 
 bool ProfileInfoCache::ProfileIsUsingDefaultNameAtIndex(size_t index) const {
   bool value = false;
   GetInfoForProfileAtIndex(index)->GetBoolean(kIsUsingDefaultNameKey, &value);
   return value;
 }
 
+bool ProfileInfoCache::ProfileIsAuthenticatedAtIndex(size_t index) const {
+  // The profile is authenticated if the gaia_id of the info is not empty.
+  // If it is empty, also check if the user name is not empty.  This latter
+  // check is needed in case the profile has not been loaded yet and the
+  // gaia_id property has not yet been written.
+  return !GetGAIAIdOfProfileAtIndex(index).empty() ||
+      !GetUserNameOfProfileAtIndex(index).empty();
+}
+
 bool ProfileInfoCache::ProfileIsUsingDefaultAvatarAtIndex(size_t index) const {
   bool value = false;
   GetInfoForProfileAtIndex(index)->GetBoolean(kIsUsingDefaultAvatarKey, &value);
   return value;
 }
 
 bool ProfileInfoCache::ProfileIsAuthErrorAtIndex(size_t index) const {
   bool value = false;
   GetInfoForProfileAtIndex(index)->GetBoolean(kIsAuthErrorKey, &value);
   return value;
@@ skipping 54 matching lines @@
     const base::string16& shortcut_name) {
   if (shortcut_name == GetShortcutNameOfProfileAtIndex(index))
     return;
   scoped_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetString(kShortcutNameKey, shortcut_name);
   // This takes ownership of |info|.
   SetInfoForProfileAtIndex(index, info.release());
 }
 
-void ProfileInfoCache::SetUserNameOfProfileAtIndex(
+void ProfileInfoCache::SetAuthInfoOfProfileAtIndex(
     size_t index,
+    const std::string& gaia_id,
     const base::string16& user_name) {
-  if (user_name == GetUserNameOfProfileAtIndex(index))
-    return;
+  scoped_ptr<base::DictionaryValue> info;
 
-  scoped_ptr<base::DictionaryValue> info(
-      GetInfoForProfileAtIndex(index)->DeepCopy());
-  info->SetString(kUserNameKey, user_name);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  if (gaia_id != GetGAIAIdOfProfileAtIndex(index)) {
+    info.reset(GetInfoForProfileAtIndex(index)->DeepCopy());

[noms (inactive), 2015/05/06 01:05:54]

Just a thought: is there a benefit from resetting |info| like this? Why not
initialize it directly with |GetInfoForProfile...| like before? Like, get and
store the old gaia_id/usernames, bail early if they're empty, and if not,
initialize info with the deep copy and set the appropriate strings. Maybe?

[Roger Tawa OOO till Jul 10th, 2015/05/11 16:09:57]

Done.

+    info->SetString(kGAIAIdKey, gaia_id);
+  }
+
+  if (user_name != GetUserNameOfProfileAtIndex(index)) {
+    if (!info)
+      info.reset(GetInfoForProfileAtIndex(index)->DeepCopy());
+
+    info->SetString(kUserNameKey, user_name);
+  }
+
+  if (info) {
+    // This takes ownership of |info|.
+    SetInfoForProfileAtIndex(index, info.release());
+  }
 
   base::FilePath profile_path = GetPathOfProfileAtIndex(index);
   FOR_EACH_OBSERVER(ProfileInfoCacheObserver,
                     observer_list_,
-                    OnProfileUserNameChanged(profile_path));
+                    OnProfileAuthInfoChanged(profile_path));
 }
 
 void ProfileInfoCache::SetAvatarIconOfProfileAtIndex(size_t index,
                                                      size_t icon_index) {
   scoped_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetString(kAvatarIconKey,
       profiles::GetDefaultAvatarIconUrl(icon_index));
   // This takes ownership of |info|.
   SetInfoForProfileAtIndex(index, info.release());
@@ skipping 629 matching lines @@
   std::vector<base::FilePath>::const_iterator it;
   for (it = profiles_to_rename.begin(); it != profiles_to_rename.end(); ++it) {
     size_t profile_index = GetIndexOfProfileWithPath(*it);
     SetProfileIsUsingDefaultNameAtIndex(profile_index, true);
     // This will assign a new "Person %d" type name and re-sort the cache.
     SetNameOfProfileAtIndex(profile_index, ChooseNameForNewProfile(
         GetAvatarIconIndexOfProfileAtIndex(profile_index)));
   }
 #endif
 }