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

net/test/spawned_test_server/base_test_server.cc

 // Copyright 2013 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 "net/test/spawned_test_server/base_test_server.h"
 
 #include <stdint.h>
 #include <limits>
 #include <string>
 #include <utility>
@@ skipping 46 matching lines @@
     case CLIENT_CERT_ECDSA_SIGN:
       return "ecdsa_sign";
     default:
       NOTREACHED();
       return "";
   }
 }
 
 void GetKeyExchangesList(int key_exchange, base::ListValue* values) {
   if (key_exchange & BaseTestServer::SSLOptions::KEY_EXCHANGE_RSA)
-    values->Append(new base::StringValue("rsa"));
+    values->AppendString("rsa");
   if (key_exchange & BaseTestServer::SSLOptions::KEY_EXCHANGE_DHE_RSA)
-    values->Append(new base::StringValue("dhe_rsa"));
+    values->AppendString("dhe_rsa");
   if (key_exchange & BaseTestServer::SSLOptions::KEY_EXCHANGE_ECDHE_RSA)
-    values->Append(new base::StringValue("ecdhe_rsa"));
+    values->AppendString("ecdhe_rsa");
 }
 
 void GetCiphersList(int cipher, base::ListValue* values) {
   if (cipher & BaseTestServer::SSLOptions::BULK_CIPHER_RC4)
-    values->Append(new base::StringValue("rc4"));
+    values->AppendString("rc4");
   if (cipher & BaseTestServer::SSLOptions::BULK_CIPHER_AES128)
-    values->Append(new base::StringValue("aes128"));
+    values->AppendString("aes128");
   if (cipher & BaseTestServer::SSLOptions::BULK_CIPHER_AES256)
-    values->Append(new base::StringValue("aes256"));
+    values->AppendString("aes256");
   if (cipher & BaseTestServer::SSLOptions::BULK_CIPHER_3DES)
-    values->Append(new base::StringValue("3des"));
+    values->AppendString("3des");
   if (cipher & BaseTestServer::SSLOptions::BULK_CIPHER_AES128GCM)
-    values->Append(new base::StringValue("aes128gcm"));
+    values->AppendString("aes128gcm");
 }
 
 base::StringValue* GetTLSIntoleranceType(
     BaseTestServer::SSLOptions::TLSIntoleranceType type) {
   switch (type) {
     case BaseTestServer::SSLOptions::TLS_INTOLERANCE_ALERT:
       return new base::StringValue("alert");
     case BaseTestServer::SSLOptions::TLS_INTOLERANCE_CLOSE:
       return new base::StringValue("close");
     case BaseTestServer::SSLOptions::TLS_INTOLERANCE_RESET:
@@ skipping 16 matching lines @@
     return false;
 
   *local_certificates_dir = src_dir.Append(certificates_dir);
   return true;
 }
 
 std::unique_ptr<base::ListValue> GetTokenBindingParams(
     std::vector<int> params) {
   std::unique_ptr<base::ListValue> values(new base::ListValue());
   for (int param : params) {
-    values->Append(new base::FundamentalValue(param));
+    values->AppendInteger(param);
   }
   return values;
 }
 
 }  // namespace
 
 BaseTestServer::SSLOptions::SSLOptions()
     : server_certificate(CERT_OK),
       ocsp_status(OCSP_OK),
       cert_serial(0),
@@ skipping 363 matching lines @@
     std::unique_ptr<base::ListValue> ssl_client_certs(new base::ListValue());
 
     std::vector<base::FilePath>::const_iterator it;
     for (it = ssl_options_.client_authorities.begin();
          it != ssl_options_.client_authorities.end(); ++it) {
       if (it->IsAbsolute() && !base::PathExists(*it)) {
         LOG(ERROR) << "Client authority path " << it->value()
                    << " doesn't exist. Can't launch https server.";
         return false;
       }
-      ssl_client_certs->Append(new base::StringValue(it->value()));
+      ssl_client_certs->AppendString(it->value());
     }
 
     if (ssl_client_certs->GetSize())
       arguments->Set("ssl-client-ca", ssl_client_certs.release());
 
     std::unique_ptr<base::ListValue> client_cert_types(new base::ListValue());
     for (size_t i = 0; i < ssl_options_.client_cert_types.size(); i++) {
-      client_cert_types->Append(new base::StringValue(
-          GetClientCertType(ssl_options_.client_cert_types[i])));
+      client_cert_types->AppendString(
+          GetClientCertType(ssl_options_.client_cert_types[i]));
     }
     if (client_cert_types->GetSize())
       arguments->Set("ssl-client-cert-type", client_cert_types.release());
   }
 
   if (type_ == TYPE_HTTPS) {
     arguments->Set("https", base::Value::CreateNullValue());
 
     std::string ocsp_arg = ssl_options_.GetOCSPArgument();
     if (!ocsp_arg.empty())
@@ skipping 30 matching lines @@
     }
     if (ssl_options_.staple_ocsp_response)
       arguments->Set("staple-ocsp-response", base::Value::CreateNullValue());
     if (ssl_options_.ocsp_server_unavailable) {
       arguments->Set("ocsp-server-unavailable",
                      base::Value::CreateNullValue());
     }
     if (!ssl_options_.npn_protocols.empty()) {
       std::unique_ptr<base::ListValue> npn_protocols(new base::ListValue());
       for (const std::string& proto : ssl_options_.npn_protocols) {
-        npn_protocols->Append(new base::StringValue(proto));
+        npn_protocols->AppendString(proto);
       }
       arguments->Set("npn-protocols", std::move(npn_protocols));
     }
     if (ssl_options_.alert_after_handshake)
       arguments->Set("alert-after-handshake", base::Value::CreateNullValue());
 
     if (ssl_options_.disable_channel_id)
       arguments->Set("disable-channel-id", base::Value::CreateNullValue());
     if (ssl_options_.disable_extended_master_secret) {
       arguments->Set("disable-extended-master-secret",
@@ skipping 10 matching lines @@
 
   return GenerateAdditionalArguments(arguments);
 }
 
 bool BaseTestServer::GenerateAdditionalArguments(
     base::DictionaryValue* arguments) const {
   return true;
 }
 
 }  // namespace net