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

chrome/browser/ui/webui/options/sync_setup_handler_unittest.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/ui/webui/options/sync_setup_handler.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
@@ skipping 500 matching lines @@
   ASSERT_FALSE(handler_->is_configuring_sync());
 }
 
 #endif  // #if !defined(OS_CHROMEOS)
 
 TEST_F(SyncSetupHandlerTest, TestSyncEverything) {
   std::string args =
       GetConfiguration(NULL, SYNC_ALL_DATA, GetAllTypes(), std::string(),
                        ENCRYPT_PASSWORDS, PAYMENTS_INTEGRATION_ENABLED);
   base::ListValue list_args;
-  list_args.Append(new base::StringValue(args));
+  list_args.AppendString(args);
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(true, _));
   handler_->HandleConfigure(&list_args);
 
   // Ensure that we navigated to the "done" state since we don't need a
   // passphrase.
   ExpectDone();
 }
 
 TEST_F(SyncSetupHandlerTest, TurnOnEncryptAll) {
   std::string args =
       GetConfiguration(NULL, SYNC_ALL_DATA, GetAllTypes(), std::string(),
                        ENCRYPT_ALL_DATA, PAYMENTS_INTEGRATION_ENABLED);
   base::ListValue list_args;
-  list_args.Append(new base::StringValue(args));
+  list_args.AppendString(args);
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsEncryptEverythingAllowed())
       .WillRepeatedly(Return(true));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, EnableEncryptEverything());
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(true, _));
   handler_->HandleConfigure(&list_args);
 
   // Ensure that we navigated to the "done" state since we don't need a
   // passphrase.
   ExpectDone();
 }
 
 TEST_F(SyncSetupHandlerTest, TestPassphraseStillRequired) {
   std::string args =
       GetConfiguration(NULL, SYNC_ALL_DATA, GetAllTypes(), std::string(),
                        ENCRYPT_PASSWORDS, PAYMENTS_INTEGRATION_ENABLED);
   base::ListValue list_args;
-  list_args.Append(new base::StringValue(args));
+  list_args.AppendString(args);
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(_, _));
   SetDefaultExpectationsForConfigPage();
 
   // We should navigate back to the configure page since we need a passphrase.
   handler_->HandleConfigure(&list_args);
 
   ExpectConfig();
 }
 
 TEST_F(SyncSetupHandlerTest, SuccessfullySetPassphrase) {
   base::DictionaryValue dict;
   dict.SetBoolean("isGooglePassphrase", true);
   std::string args =
       GetConfiguration(&dict, SYNC_ALL_DATA, GetAllTypes(), "gaiaPassphrase",
                        ENCRYPT_PASSWORDS, PAYMENTS_INTEGRATION_ENABLED);
   base::ListValue list_args;
-  list_args.Append(new base::StringValue(args));
+  list_args.AppendString(args);
   // Act as if an encryption passphrase is required the first time, then never
   // again after that.
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired()).WillOnce(Return(true));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(_, _));
   EXPECT_CALL(*mock_pss_, SetDecryptionPassphrase("gaiaPassphrase")).
       WillOnce(Return(true));
 
   handler_->HandleConfigure(&list_args);
   // We should navigate to "done" page since we finished configuring.
   ExpectDone();
 }
 
 TEST_F(SyncSetupHandlerTest, SelectCustomEncryption) {
   base::DictionaryValue dict;
   dict.SetBoolean("isGooglePassphrase", false);
   std::string args =
       GetConfiguration(&dict, SYNC_ALL_DATA, GetAllTypes(), "custom_passphrase",
                        ENCRYPT_PASSWORDS, PAYMENTS_INTEGRATION_ENABLED);
   base::ListValue list_args;
-  list_args.Append(new base::StringValue(args));
+  list_args.AppendString(args);
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(_, _));
   EXPECT_CALL(*mock_pss_,
               SetEncryptionPassphrase("custom_passphrase",
                                       ProfileSyncService::EXPLICIT));
 
   handler_->HandleConfigure(&list_args);
   // We should navigate to "done" page since we finished configuring.
   ExpectDone();
 }
 
 TEST_F(SyncSetupHandlerTest, UnsuccessfullySetPassphrase) {
   base::DictionaryValue dict;
   dict.SetBoolean("isGooglePassphrase", true);
   std::string args = GetConfiguration(&dict, SYNC_ALL_DATA, GetAllTypes(),
                                       "invalid_passphrase", ENCRYPT_PASSWORDS,
                                       PAYMENTS_INTEGRATION_ENABLED);
   base::ListValue list_args;
-  list_args.Append(new base::StringValue(args));
+  list_args.AppendString(args);
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_pss_, IsUsingSecondaryPassphrase())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(_, _));
   EXPECT_CALL(*mock_pss_, SetDecryptionPassphrase("invalid_passphrase")).
       WillOnce(Return(false));
@@ skipping 17 matching lines @@
 TEST_F(SyncSetupHandlerTest, TestSyncIndividualTypes) {
   syncer::ModelTypeSet user_selectable_types = GetAllTypes();
   syncer::ModelTypeSet::Iterator it;
   for (it = user_selectable_types.First(); it.Good(); it.Inc()) {
     syncer::ModelTypeSet type_to_set;
     type_to_set.Put(it.Get());
     std::string args =
         GetConfiguration(NULL, CHOOSE_WHAT_TO_SYNC, type_to_set, std::string(),
                          ENCRYPT_PASSWORDS, PAYMENTS_INTEGRATION_ENABLED);
     base::ListValue list_args;
-    list_args.Append(new base::StringValue(args));
+    list_args.AppendString(args);
     EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
         .WillRepeatedly(Return(false));
     EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
         .WillRepeatedly(Return(false));
     SetupInitializedProfileSyncService();
     EXPECT_CALL(*mock_pss_,
                 OnUserChoseDatatypes(false, ModelTypeSetMatches(type_to_set)));
     handler_->HandleConfigure(&list_args);
 
     ExpectDone();
     Mock::VerifyAndClearExpectations(mock_pss_);
     web_ui_.ClearTrackedCalls();
   }
 }
 
 TEST_F(SyncSetupHandlerTest, TestSyncAllManually) {
   std::string args =
       GetConfiguration(NULL, CHOOSE_WHAT_TO_SYNC, GetAllTypes(), std::string(),
                        ENCRYPT_PASSWORDS, PAYMENTS_INTEGRATION_ENABLED);
   base::ListValue list_args;
-  list_args.Append(new base::StringValue(args));
+  list_args.AppendString(args);
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_,
               OnUserChoseDatatypes(false, ModelTypeSetMatches(GetAllTypes())));
   handler_->HandleConfigure(&list_args);
 
   ExpectDone();
@@ skipping 219 matching lines @@
   ASSERT_TRUE(data.arg2()->GetAsDictionary(&dictionary));
   CheckBool(dictionary, "encryptAllData", false);
   CheckBool(dictionary, "encryptAllDataAllowed", false);
 }
 
 TEST_F(SyncSetupHandlerTest, TurnOnEncryptAllDisallowed) {
   std::string args =
       GetConfiguration(NULL, SYNC_ALL_DATA, GetAllTypes(), std::string(),
                        ENCRYPT_ALL_DATA, PAYMENTS_INTEGRATION_ENABLED);
   base::ListValue list_args;
-  list_args.Append(new base::StringValue(args));
+  list_args.AppendString(args);
   EXPECT_CALL(*mock_pss_, IsPassphraseRequiredForDecryption())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, IsPassphraseRequired())
       .WillRepeatedly(Return(false));
   SetupInitializedProfileSyncService();
   EXPECT_CALL(*mock_pss_, IsEncryptEverythingAllowed())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*mock_pss_, EnableEncryptEverything()).Times(0);
   EXPECT_CALL(*mock_pss_, OnUserChoseDatatypes(true, _));
   handler_->HandleConfigure(&list_args);
 
   // Ensure that we navigated to the "done" state since we don't need a
   // passphrase.
   ExpectDone();
 }