Remove raw base::DictionaryValue::SetWithoutPathExpansion

ios/chrome/browser/browser_state/browser_state_info_cache.cc

 // Copyright 2015 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 "ios/chrome/browser/browser_state/browser_state_info_cache.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
+#include <utility>
 
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "ios/chrome/browser/browser_state/browser_state_info_cache_observer.h"
 #include "ios/chrome/browser/pref_names.h"
 
 namespace {
 const char kGAIAIdKey[] = "gaia_id";
 const char kIsAuthErrorKey[] = "is_auth_error";
 const char kUserNameKey[] = "user_name";
@@ skipping 20 matching lines @@
     const base::FilePath& browser_state_path,
     const std::string& gaia_id,
     const base::string16& user_name) {
   std::string key = CacheKeyFromBrowserStatePath(browser_state_path);
   DictionaryPrefUpdate update(prefs_, prefs::kBrowserStateInfoCache);
   base::DictionaryValue* cache = update.Get();
 
   std::unique_ptr<base::DictionaryValue> info(new base::DictionaryValue);
   info->SetString(kGAIAIdKey, gaia_id);
   info->SetString(kUserNameKey, user_name);
-  cache->SetWithoutPathExpansion(key, info.release());
+  cache->SetWithoutPathExpansion(key, std::move(info));
   AddBrowserStateCacheKey(key);
 
   for (auto& observer : observer_list_)
     observer.OnBrowserStateAdded(browser_state_path);
 }
 
 void BrowserStateInfoCache::AddObserver(
     BrowserStateInfoCacheObserver* observer) {
   observer_list_.AddObserver(observer);
 }
@@ skipping 75 matching lines @@
 void BrowserStateInfoCache::SetAuthInfoOfBrowserStateAtIndex(
     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 == GetGAIAIdOfBrowserStateAtIndex(index) &&
       user_name == GetUserNameOfBrowserStateAtIndex(index)) {
     return;
   }
 
-  std::unique_ptr<base::DictionaryValue> info(
-      GetInfoForBrowserStateAtIndex(index)->DeepCopy());
+  auto info = base::MakeUnique<base::DictionaryValue>(
+      *GetInfoForBrowserStateAtIndex(index));
 
   info->SetString(kGAIAIdKey, gaia_id);
   info->SetString(kUserNameKey, user_name);
 
-  // This takes ownership of |info|.
-  SetInfoForBrowserStateAtIndex(index, info.release());
+  SetInfoForBrowserStateAtIndex(index, std::move(info));
 }
 
 void BrowserStateInfoCache::SetBrowserStateIsAuthErrorAtIndex(size_t index,
                                                               bool value) {
   if (value == BrowserStateIsAuthErrorAtIndex(index))
     return;
 
-  std::unique_ptr<base::DictionaryValue> info(
-      GetInfoForBrowserStateAtIndex(index)->DeepCopy());
+  auto info = base::MakeUnique<base::DictionaryValue>(
+      *GetInfoForBrowserStateAtIndex(index));
   info->SetBoolean(kIsAuthErrorKey, value);
-  // This takes ownership of |info|.
-  SetInfoForBrowserStateAtIndex(index, info.release());
+  SetInfoForBrowserStateAtIndex(index, std::move(info));
 }
 
 const base::FilePath& BrowserStateInfoCache::GetUserDataDir() const {
   return user_data_dir_;
 }
 
 // static
 void BrowserStateInfoCache::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(prefs::kBrowserStateInfoCache);
 }
 
 const base::DictionaryValue*
 BrowserStateInfoCache::GetInfoForBrowserStateAtIndex(size_t index) const {
   DCHECK_LT(index, GetNumberOfBrowserStates());
   const base::DictionaryValue* cache =
       prefs_->GetDictionary(prefs::kBrowserStateInfoCache);
   const base::DictionaryValue* info = nullptr;
   cache->GetDictionaryWithoutPathExpansion(sorted_keys_[index], &info);
   return info;
 }
 
 void BrowserStateInfoCache::SetInfoForBrowserStateAtIndex(
     size_t index,
-    base::DictionaryValue* info) {
+    std::unique_ptr<base::DictionaryValue> info) {
   DictionaryPrefUpdate update(prefs_, prefs::kBrowserStateInfoCache);
   base::DictionaryValue* cache = update.Get();
-  cache->SetWithoutPathExpansion(sorted_keys_[index], info);
+  cache->SetWithoutPathExpansion(sorted_keys_[index], std::move(info));
 }
 
 std::string BrowserStateInfoCache::CacheKeyFromBrowserStatePath(
     const base::FilePath& browser_state_path) const {
   DCHECK(user_data_dir_ == browser_state_path.DirName());
   base::FilePath base_name = browser_state_path.BaseName();
   return base_name.MaybeAsASCII();
 }
 
 void BrowserStateInfoCache::AddBrowserStateCacheKey(const std::string& key) {
   sorted_keys_.insert(
       std::upper_bound(sorted_keys_.begin(), sorted_keys_.end(), key), key);
 }