Remove ListValue::Append(new {Fundamental,String}Value(...)) pattern in //components

components/syncable_prefs/pref_model_associator_unittest.cc

 // Copyright (c) 2011 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/syncable_prefs/pref_model_associator.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 88 matching lines @@
   PrefModelAssociator* pref_sync_service_;
 };
 
 class ListPreferenceMergeTest : public AbstractPreferenceMergeTest {
  protected:
   ListPreferenceMergeTest()
       : server_url0_("http://example.com/server0"),
         server_url1_("http://example.com/server1"),
         local_url0_("http://example.com/local0"),
         local_url1_("http://example.com/local1") {
-    server_url_list_.Append(new base::StringValue(server_url0_));
-    server_url_list_.Append(new base::StringValue(server_url1_));
+    server_url_list_.AppendString(server_url0_);
+    server_url_list_.AppendString(server_url1_);
   }
 
   std::string server_url0_;
   std::string server_url1_;
   std::string local_url0_;
   std::string local_url1_;
   base::ListValue server_url_list_;
 };
 
 TEST_F(ListPreferenceMergeTest, NotListOrDictionary) {
@@ skipping 14 matching lines @@
   std::unique_ptr<base::Value> merged_value(pref_sync_service_->MergePreference(
       pref->name(), *pref->GetValue(), server_url_list_));
   EXPECT_TRUE(merged_value->Equals(&server_url_list_));
 }
 
 TEST_F(ListPreferenceMergeTest, ServerNull) {
   std::unique_ptr<base::Value> null_value = base::Value::CreateNullValue();
   {
     ListPrefUpdate update(pref_service_.get(), kListPrefName);
     base::ListValue* local_list_value = update.Get();
-    local_list_value->Append(new base::StringValue(local_url0_));
+    local_list_value->AppendString(local_url0_);
   }
 
   const PrefService::Preference* pref =
       pref_service_->FindPreference(kListPrefName);
   std::unique_ptr<base::Value> merged_value(pref_sync_service_->MergePreference(
       pref->name(), *pref->GetValue(), *null_value));
   const base::ListValue* local_list_value =
         pref_service_->GetList(kListPrefName);
   EXPECT_TRUE(merged_value->Equals(local_list_value));
 }
 
 TEST_F(ListPreferenceMergeTest, ServerEmpty) {
   std::unique_ptr<base::Value> empty_value(new base::ListValue);
   {
     ListPrefUpdate update(pref_service_.get(), kListPrefName);
     base::ListValue* local_list_value = update.Get();
-    local_list_value->Append(new base::StringValue(local_url0_));
+    local_list_value->AppendString(local_url0_);
   }
 
   const PrefService::Preference* pref =
       pref_service_->FindPreference(kListPrefName);
   std::unique_ptr<base::Value> merged_value(pref_sync_service_->MergePreference(
       pref->name(), *pref->GetValue(), *empty_value));
   const base::ListValue* local_list_value =
         pref_service_->GetList(kListPrefName);
   EXPECT_TRUE(merged_value->Equals(local_list_value));
 }
 
 TEST_F(ListPreferenceMergeTest, Merge) {
   {
     ListPrefUpdate update(pref_service_.get(), kListPrefName);
     base::ListValue* local_list_value = update.Get();
-    local_list_value->Append(new base::StringValue(local_url0_));
-    local_list_value->Append(new base::StringValue(local_url1_));
+    local_list_value->AppendString(local_url0_);
+    local_list_value->AppendString(local_url1_);
   }
 
   const PrefService::Preference* pref =
       pref_service_->FindPreference(kListPrefName);
   std::unique_ptr<base::Value> merged_value(pref_sync_service_->MergePreference(
       pref->name(), *pref->GetValue(), server_url_list_));
 
   base::ListValue expected;
-  expected.Append(new base::StringValue(server_url0_));
-  expected.Append(new base::StringValue(server_url1_));
-  expected.Append(new base::StringValue(local_url0_));
-  expected.Append(new base::StringValue(local_url1_));
+  expected.AppendString(server_url0_);
+  expected.AppendString(server_url1_);
+  expected.AppendString(local_url0_);
+  expected.AppendString(local_url1_);
   EXPECT_TRUE(merged_value->Equals(&expected));
 }
 
 TEST_F(ListPreferenceMergeTest, Duplicates) {
   {
     ListPrefUpdate update(pref_service_.get(), kListPrefName);
     base::ListValue* local_list_value = update.Get();
-    local_list_value->Append(new base::StringValue(local_url0_));
-    local_list_value->Append(new base::StringValue(server_url0_));
-    local_list_value->Append(new base::StringValue(server_url1_));
+    local_list_value->AppendString(local_url0_);
+    local_list_value->AppendString(server_url0_);
+    local_list_value->AppendString(server_url1_);
   }
 
   const PrefService::Preference* pref =
       pref_service_->FindPreference(kListPrefName);
   std::unique_ptr<base::Value> merged_value(pref_sync_service_->MergePreference(
       pref->name(), *pref->GetValue(), server_url_list_));
 
   base::ListValue expected;
-  expected.Append(new base::StringValue(server_url0_));
-  expected.Append(new base::StringValue(server_url1_));
-  expected.Append(new base::StringValue(local_url0_));
+  expected.AppendString(server_url0_);
+  expected.AppendString(server_url1_);
+  expected.AppendString(local_url0_);
   EXPECT_TRUE(merged_value->Equals(&expected));
 }
 
 TEST_F(ListPreferenceMergeTest, Equals) {
   {
     ListPrefUpdate update(pref_service_.get(), kListPrefName);
     base::ListValue* local_list_value = update.Get();
-    local_list_value->Append(new base::StringValue(server_url0_));
-    local_list_value->Append(new base::StringValue(server_url1_));
+    local_list_value->AppendString(server_url0_);
+    local_list_value->AppendString(server_url1_);
   }
 
   std::unique_ptr<base::Value> original(server_url_list_.DeepCopy());
   const PrefService::Preference* pref =
       pref_service_->FindPreference(kListPrefName);
   std::unique_ptr<base::Value> merged_value(pref_sync_service_->MergePreference(
       pref->name(), *pref->GetValue(), server_url_list_));
   EXPECT_TRUE(merged_value->Equals(original.get()));
 }
 
@@ skipping 150 matching lines @@
   EXPECT_TRUE(merged_value->Equals(&server_patterns_));
 }
 
 class IndividualPreferenceMergeTest : public AbstractPreferenceMergeTest {
  protected:
   IndividualPreferenceMergeTest()
       : url0_("http://example.com/server0"),
         url1_("http://example.com/server1"),
         expression0_("expression0"),
         expression1_("expression1") {
-    server_url_list_.Append(new base::StringValue(url0_));
+    server_url_list_.AppendString(url0_);
     SetContentPattern(&server_patterns_, expression0_, 1);
   }
 
   bool MergeListPreference(const char* pref) {
     {
       ListPrefUpdate update(pref_service_.get(), pref);
       base::ListValue* local_list_value = update.Get();
-      local_list_value->Append(new base::StringValue(url1_));
+      local_list_value->AppendString(url1_);
     }
 
     std::unique_ptr<base::Value> merged_value(
         pref_sync_service_->MergePreference(
             pref, *pref_service_->GetUserPrefValue(pref), server_url_list_));
 
     base::ListValue expected;
-    expected.Append(new base::StringValue(url0_));
-    expected.Append(new base::StringValue(url1_));
+    expected.AppendString(url0_);
+    expected.AppendString(url1_);
     return merged_value->Equals(&expected);
   }
 
   bool MergeDictionaryPreference(const char* pref) {
     {
       DictionaryPrefUpdate update(pref_service_.get(), pref);
       base::DictionaryValue* local_dict_value = update.Get();
       SetContentPattern(local_dict_value, expression1_, 1);
     }
 
@@ skipping 16 matching lines @@
   base::DictionaryValue server_patterns_;
 };
 
 TEST_F(IndividualPreferenceMergeTest, ListPreference) {
   EXPECT_TRUE(MergeListPreference(kListPrefName));
 }
 
 }  // namespace
 
 }  // namespace syncable_prefs