Remove raw base::DictionaryValue::SetWithoutPathExpansion

components/sync_preferences/pref_model_associator.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 "components/sync_preferences/pref_model_associator.h"
 
+#include <algorithm>
+#include <iterator>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 214 matching lines @@
 
 std::unique_ptr<base::Value> PrefModelAssociator::MergePreference(
     const std::string& name,
     const base::Value& local_value,
     const base::Value& server_value) {
   // This function special cases preferences individually, so don't attempt
   // to merge for all migrated values.
   if (client_) {
     std::string new_pref_name;
     if (client_->IsMergeableListPreference(name))
-      return base::WrapUnique(MergeListValues(local_value, server_value));
+      return MergeListValues(local_value, server_value);
     if (client_->IsMergeableDictionaryPreference(name))
-      return base::WrapUnique(MergeDictionaryValues(local_value, server_value));
+      return MergeDictionaryValues(local_value, server_value);
   }
 
   // If this is not a specially handled preference, server wins.
   return base::WrapUnique(server_value.DeepCopy());
 }
 
 bool PrefModelAssociator::CreatePrefSyncData(
     const std::string& name,
     const base::Value& value,
     syncer::SyncData* sync_data) const {
@@ skipping 14 matching lines @@
   sync_pb::EntitySpecifics specifics;
   sync_pb::PreferenceSpecifics* pref_specifics =
       GetMutableSpecifics(type_, &specifics);
 
   pref_specifics->set_name(name);
   pref_specifics->set_value(serialized);
   *sync_data = syncer::SyncData::CreateLocalData(name, name, specifics);
   return true;
 }
 
-base::Value* PrefModelAssociator::MergeListValues(const base::Value& from_value,
-                                                  const base::Value& to_value) {
+std::unique_ptr<base::Value> PrefModelAssociator::MergeListValues(
+    const base::Value& from_value,
+    const base::Value& to_value) {
   if (from_value.GetType() == base::Value::Type::NONE)
-    return to_value.DeepCopy();
+    return base::MakeUnique<base::Value>(to_value);
   if (to_value.GetType() == base::Value::Type::NONE)
-    return from_value.DeepCopy();
+    return base::MakeUnique<base::Value>(from_value);
 
   DCHECK(from_value.GetType() == base::Value::Type::LIST);
   DCHECK(to_value.GetType() == base::Value::Type::LIST);
   const base::ListValue& from_list_value =
       static_cast<const base::ListValue&>(from_value);
   const base::ListValue& to_list_value =
       static_cast<const base::ListValue&>(to_value);
-  base::ListValue* result = to_list_value.DeepCopy();
 
-  for (const auto& value : from_list_value) {
-    result->AppendIfNotPresent(value.CreateDeepCopy());
-  }
-  return result;
+  auto result = base::MakeUnique<base::ListValue>(to_list_value);
+  base::Value::ListStorage& list = result->GetList();
+  std::copy_if(
+      from_list_value.GetList().begin(), from_list_value.GetList().end(),
+      std::back_inserter(list), [&list](const base::Value& value) {
+        return std::find(list.begin(), list.end(), value) == list.end();
+      });
+  return std::move(result);
 }
 
-base::Value* PrefModelAssociator::MergeDictionaryValues(
+std::unique_ptr<base::Value> PrefModelAssociator::MergeDictionaryValues(
     const base::Value& from_value,
     const base::Value& to_value) {
   if (from_value.GetType() == base::Value::Type::NONE)
-    return to_value.DeepCopy();
+    return base::MakeUnique<base::Value>(to_value);
   if (to_value.GetType() == base::Value::Type::NONE)
-    return from_value.DeepCopy();
+    return base::MakeUnique<base::Value>(from_value);
 
   DCHECK_EQ(from_value.GetType(), base::Value::Type::DICTIONARY);
   DCHECK_EQ(to_value.GetType(), base::Value::Type::DICTIONARY);
   const base::DictionaryValue& from_dict_value =
       static_cast<const base::DictionaryValue&>(from_value);
   const base::DictionaryValue& to_dict_value =
       static_cast<const base::DictionaryValue&>(to_value);
-  base::DictionaryValue* result = to_dict_value.DeepCopy();
+  auto result = base::MakeUnique<base::DictionaryValue>(to_dict_value);
 
   for (base::DictionaryValue::Iterator it(from_dict_value); !it.IsAtEnd();
        it.Advance()) {
     const base::Value* from_key_value = &it.value();
     base::Value* to_key_value;
     if (result->GetWithoutPathExpansion(it.key(), &to_key_value)) {
       if (from_key_value->GetType() == base::Value::Type::DICTIONARY &&
           to_key_value->GetType() == base::Value::Type::DICTIONARY) {
-        base::Value* merged_value =
+        std::unique_ptr<base::Value> merged_value =
             MergeDictionaryValues(*from_key_value, *to_key_value);
-        result->SetWithoutPathExpansion(it.key(), merged_value);
+        result->SetWithoutPathExpansion(it.key(), std::move(merged_value));
       }
       // Note that for all other types we want to preserve the "to"
       // values so we do nothing here.
     } else {
-      result->SetWithoutPathExpansion(it.key(), from_key_value->DeepCopy());
+      result->SetWithoutPathExpansion(
+          it.key(), base::MakeUnique<base::Value>(*from_key_value));
     }
   }
-  return result;
+  return std::move(result);
 }
 
 // Note: This will build a model of all preferences registered as syncable
 // with user controlled data. We do not track any information for preferences
 // not registered locally as syncable and do not inform the syncer of
 // non-user controlled preferences.
 syncer::SyncDataList PrefModelAssociator::GetAllSyncData(
     syncer::ModelType type) const {
   DCHECK_EQ(type_, type);
   syncer::SyncDataList current_data;
@@ skipping 181 matching lines @@
                                                     bool from_sync) const {
   auto observer_iter = synced_pref_observers_.find(path);
   if (observer_iter == synced_pref_observers_.end())
     return;
   SyncedPrefObserverList* observers = observer_iter->second.get();
   for (auto& observer : *observers)
     observer.OnSyncedPrefChanged(path, from_sync);
 }
 
 }  // namespace sync_preferences