Remove raw base::DictionaryValue::SetWithoutPathExpansion in //chrome

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 <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 183 matching lines @@
   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);
-  cache->SetWithoutPathExpansion(key, info.release());
+  cache->SetWithoutPathExpansion(key, std::move(info));
 
   sorted_keys_.insert(FindPositionForProfile(key, name), key);
   profile_attributes_entries_[user_data_dir_.AppendASCII(key).value()] =
       std::unique_ptr<ProfileAttributesEntry>();
 
   if (!disable_avatar_download_for_testing_)
     DownloadHighResAvatarIfNeeded(icon_index, profile_path);
 
   for (auto& observer : observer_list_)
     observer.OnProfileAdded(profile_path);
@@ skipping 314 matching lines @@
 
 void ProfileInfoCache::SetProfileActiveTimeAtIndex(size_t index) {
   if (base::Time::Now() - GetProfileActiveTimeAtIndex(index) <
       base::TimeDelta::FromHours(1)) {
     return;
   }
 
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetDouble(kActiveTimeKey, base::Time::Now().ToDoubleT());
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 }
 
 void ProfileInfoCache::SetNameOfProfileAtIndex(size_t index,
                                                const base::string16& name) {
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   base::string16 current_name;
   info->GetString(kNameKey, &current_name);
   if (name == current_name)
     return;
 
   base::string16 old_display_name = GetNameOfProfileAtIndex(index);
   info->SetString(kNameKey, name);
 
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 
   base::string16 new_display_name = GetNameOfProfileAtIndex(index);
   base::FilePath profile_path = GetPathOfProfileAtIndex(index);
   UpdateSortForProfileIndex(index);
 
   if (old_display_name != new_display_name) {
     for (auto& observer : observer_list_)
       observer.OnProfileNameChanged(profile_path, old_display_name);
   }
 }
 
 void ProfileInfoCache::SetShortcutNameOfProfileAtIndex(
     size_t index,
     const base::string16& shortcut_name) {
   if (shortcut_name == GetShortcutNameOfProfileAtIndex(index))
     return;
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetString(kShortcutNameKey, shortcut_name);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 }
 
 void ProfileInfoCache::SetAuthInfoOfProfileAtIndex(
     size_t index,
     const std::string& gaia_id,
     const base::string16& user_name) {
   // If both gaia_id and username are unchanged, abort early.
   if (gaia_id == GetGAIAIdOfProfileAtIndex(index) &&
       user_name == GetUserNameOfProfileAtIndex(index)) {
     return;
   }
 
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
 
   info->SetString(kGAIAIdKey, gaia_id);
   info->SetString(kUserNameKey, user_name);
 
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 
   base::FilePath profile_path = GetPathOfProfileAtIndex(index);
   for (auto& observer : observer_list_)
     observer.OnProfileAuthInfoChanged(profile_path);
 }
 
 void ProfileInfoCache::SetAvatarIconOfProfileAtIndex(size_t index,
                                                      size_t icon_index) {
   if (!profiles::IsDefaultAvatarIconIndex(icon_index)) {
     DLOG(WARNING) << "Unknown avatar icon index: " << icon_index;
     // switch to generic avatar
     icon_index = 0;
   }
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetString(kAvatarIconKey,
       profiles::GetDefaultAvatarIconUrl(icon_index));
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 
   base::FilePath profile_path = GetPathOfProfileAtIndex(index);
 
   if (!disable_avatar_download_for_testing_)
     DownloadHighResAvatarIfNeeded(icon_index, profile_path);
 
   for (auto& observer : observer_list_)
     observer.OnProfileAvatarChanged(profile_path);
 }
 
 void ProfileInfoCache::SetIsOmittedProfileAtIndex(size_t index,
                                                   bool is_omitted) {
   if (IsOmittedProfileAtIndex(index) == is_omitted)
     return;
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetBoolean(kIsOmittedFromProfileListKey, is_omitted);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 
   base::FilePath profile_path = GetPathOfProfileAtIndex(index);
   for (auto& observer : observer_list_)
     observer.OnProfileIsOmittedChanged(profile_path);
 }
 
 void ProfileInfoCache::SetSupervisedUserIdOfProfileAtIndex(
     size_t index,
     const std::string& id) {
   if (GetSupervisedUserIdOfProfileAtIndex(index) == id)
     return;
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetString(kSupervisedUserId, id);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 
   base::FilePath profile_path = GetPathOfProfileAtIndex(index);
   for (auto& observer : observer_list_)
     observer.OnProfileSupervisedUserIdChanged(profile_path);
 }
 
 void ProfileInfoCache::SetLocalAuthCredentialsOfProfileAtIndex(
     size_t index,
     const std::string& credentials) {
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetString(kAuthCredentialsKey, credentials);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 }
 
 void ProfileInfoCache::SetPasswordChangeDetectionTokenAtIndex(
     size_t index,
     const std::string& token) {
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetString(kPasswordTokenKey, token);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 }
 
 void ProfileInfoCache::SetBackgroundStatusOfProfileAtIndex(
     size_t index,
     bool running_background_apps) {
   if (GetBackgroundStatusOfProfileAtIndex(index) == running_background_apps)
     return;
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetBoolean(kBackgroundAppsKey, running_background_apps);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 }
 
 void ProfileInfoCache::SetGAIANameOfProfileAtIndex(size_t index,
                                                    const base::string16& name) {
   if (name == GetGAIANameOfProfileAtIndex(index))
     return;
 
   base::string16 old_display_name = GetNameOfProfileAtIndex(index);
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetString(kGAIANameKey, name);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
   base::string16 new_display_name = GetNameOfProfileAtIndex(index);
   base::FilePath profile_path = GetPathOfProfileAtIndex(index);
   UpdateSortForProfileIndex(index);
 
   if (old_display_name != new_display_name) {
     for (auto& observer : observer_list_)
       observer.OnProfileNameChanged(profile_path, old_display_name);
   }
 }
 
 void ProfileInfoCache::SetGAIAGivenNameOfProfileAtIndex(
     size_t index,
     const base::string16& name) {
   if (name == GetGAIAGivenNameOfProfileAtIndex(index))
     return;
 
   base::string16 old_display_name = GetNameOfProfileAtIndex(index);
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetString(kGAIAGivenNameKey, name);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
   base::string16 new_display_name = GetNameOfProfileAtIndex(index);
   base::FilePath profile_path = GetPathOfProfileAtIndex(index);
   UpdateSortForProfileIndex(index);
 
   if (old_display_name != new_display_name) {
     for (auto& observer : observer_list_)
       observer.OnProfileNameChanged(profile_path, old_display_name);
   }
 }
 
@@ skipping 22 matching lines @@
     new_file_name =
         old_file_name.empty() ? profiles::kGAIAPictureFileName : old_file_name;
     base::FilePath image_path = path.AppendASCII(new_file_name);
     SaveAvatarImageAtPath(
         GetPathOfProfileAtIndex(index), image, key, image_path);
   }
 
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetString(kGAIAPictureFileNameKey, new_file_name);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 
   for (auto& observer : observer_list_)
     observer.OnProfileAvatarChanged(path);
 }
 
 void ProfileInfoCache::SetIsUsingGAIAPictureOfProfileAtIndex(size_t index,
                                                              bool value) {
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetBoolean(kUseGAIAPictureKey, value);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 
   base::FilePath profile_path = GetPathOfProfileAtIndex(index);
   for (auto& observer : observer_list_)
     observer.OnProfileAvatarChanged(profile_path);
 }
 
 void ProfileInfoCache::SetProfileSigninRequiredAtIndex(size_t index,
                                                        bool value) {
   if (value == ProfileIsSigninRequiredAtIndex(index))
     return;
 
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetBoolean(kSigninRequiredKey, value);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
   NotifyIsSigninRequiredChanged(GetPathOfProfileAtIndex(index));
 }
 
 void ProfileInfoCache::SetProfileIsEphemeralAtIndex(size_t index, bool value) {
   if (value == ProfileIsEphemeralAtIndex(index))
     return;
 
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetBoolean(kProfileIsEphemeral, value);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 }
 
 void ProfileInfoCache::SetProfileIsUsingDefaultNameAtIndex(
     size_t index, bool value) {
   if (value == ProfileIsUsingDefaultNameAtIndex(index))
     return;
 
   base::string16 old_display_name = GetNameOfProfileAtIndex(index);
 
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetBoolean(kIsUsingDefaultNameKey, value);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 
   base::string16 new_display_name = GetNameOfProfileAtIndex(index);
   const base::FilePath profile_path = GetPathOfProfileAtIndex(index);
 
   if (old_display_name != new_display_name) {
     for (auto& observer : observer_list_)
       observer.OnProfileNameChanged(profile_path, old_display_name);
   }
 }
 
 void ProfileInfoCache::SetProfileIsUsingDefaultAvatarAtIndex(
     size_t index, bool value) {
   if (value == ProfileIsUsingDefaultAvatarAtIndex(index))
     return;
 
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetBoolean(kIsUsingDefaultAvatarKey, value);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 }
 
 void ProfileInfoCache::SetProfileIsAuthErrorAtIndex(size_t index, bool value) {
   if (value == ProfileIsAuthErrorAtIndex(index))
     return;
 
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetBoolean(kIsAuthErrorKey, value);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 }
 
 void ProfileInfoCache::SetStatsBrowsingHistoryOfProfileAtIndex(size_t index,
                                                                int value) {
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetInteger(kStatsBrowsingHistoryKey, value);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 }
 
 void ProfileInfoCache::SetStatsPasswordsOfProfileAtIndex(size_t index,
                                                          int value) {
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetInteger(kStatsPasswordsKey, value);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 }
 
 void ProfileInfoCache::SetStatsBookmarksOfProfileAtIndex(size_t index,
                                                          int value) {
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetInteger(kStatsBookmarksKey, value);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 }
 
 void ProfileInfoCache::SetStatsSettingsOfProfileAtIndex(size_t index,
                                                         int value) {
   std::unique_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetInteger(kStatsSettingsKey, value);
-  // This takes ownership of |info|.
-  SetInfoForProfileAtIndex(index, info.release());
+  SetInfoForProfileAtIndex(index, std::move(info));
 }
 
 void ProfileInfoCache::NotifyIsSigninRequiredChanged(
     const base::FilePath& profile_path) {
   for (auto& observer : observer_list_)
     observer.OnProfileSigninRequiredChanged(profile_path);
 }
 
 const base::FilePath& ProfileInfoCache::GetUserDataDir() const {
   return user_data_dir_;
@@ skipping 67 matching lines @@
 const base::DictionaryValue* ProfileInfoCache::GetInfoForProfileAtIndex(
     size_t index) const {
   DCHECK_LT(index, GetNumberOfProfiles());
   const base::DictionaryValue* cache =
       prefs_->GetDictionary(prefs::kProfileInfoCache);
   const base::DictionaryValue* info = NULL;
   cache->GetDictionaryWithoutPathExpansion(sorted_keys_[index], &info);
   return info;
 }
 
-void ProfileInfoCache::SetInfoForProfileAtIndex(size_t index,
-                                                base::DictionaryValue* info) {
+void ProfileInfoCache::SetInfoForProfileAtIndex(
+    size_t index,
+    std::unique_ptr<base::DictionaryValue> info) {
   DictionaryPrefUpdate update(prefs_, prefs::kProfileInfoCache);
   base::DictionaryValue* cache = update.Get();
-  cache->SetWithoutPathExpansion(sorted_keys_[index], info);
+  cache->SetWithoutPathExpansion(sorted_keys_[index], std::move(info));
 }
 
 std::string ProfileInfoCache::CacheKeyFromProfilePath(
     const base::FilePath& profile_path) const {
   DCHECK(user_data_dir_ == profile_path.DirName());
   base::FilePath base_name = profile_path.BaseName();
   return base_name.MaybeAsASCII();
 }
 
 std::vector<std::string>::iterator ProfileInfoCache::FindPositionForProfile(
@@ skipping 243 matching lines @@
   if (!current_entry) {
     // The profile info is in the cache but its entry isn't created yet, insert
     // it in the map.
     current_entry.reset(new ProfileAttributesEntry());
     current_entry->Initialize(this, path);
   }
 
   *entry = current_entry.get();
   return true;
 }