Remove raw DictionaryValue::Set in //components

components/webcrypto/algorithms/aes_cbc_unittest.cc

 // Copyright 2014 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 <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
+#include <utility>
+
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "components/webcrypto/algorithm_dispatch.h"
 #include "components/webcrypto/algorithms/test_helpers.h"
 #include "components/webcrypto/crypto_data.h"
 #include "components/webcrypto/status.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h"
 #include "third_party/WebKit/public/platform/WebCryptoKeyAlgorithm.h"
 
 namespace webcrypto {
 
@@ skipping 192 matching lines @@
                       0, &key));
 }
 
 // If key_ops is specified but empty, no key usages are allowed for the key.
 TEST_F(WebCryptoAesCbcTest, ImportKeyJwkEmptyKeyOps) {
   blink::WebCryptoKey key;
   base::DictionaryValue dict;
   dict.SetString("kty", "oct");
   dict.SetBoolean("ext", false);
   dict.SetString("k", "GADWrMRHwQfoNaXU5fZvTg");
-  dict.Set("key_ops", new base::ListValue);  // Takes ownership.
+  dict.Set("key_ops", base::MakeUnique<base::ListValue>());
 
   // The JWK does not contain encrypt usages.
   EXPECT_EQ(Status::ErrorJwkKeyopsInconsistent(),
             ImportKeyJwkFromDict(
                 dict, CreateAlgorithm(blink::kWebCryptoAlgorithmIdAesCbc),
                 false, blink::kWebCryptoKeyUsageEncrypt, &key));
 
   // The JWK does not contain sign usage (nor is it applicable).
   EXPECT_EQ(Status::ErrorCreateKeyBadUsages(),
             ImportKeyJwkFromDict(
@@ skipping 20 matching lines @@
             ImportKeyJwkFromDict(
                 dict, CreateAlgorithm(blink::kWebCryptoAlgorithmIdAesCbc),
                 false, blink::kWebCryptoKeyUsageVerify, &key));
 }
 
 TEST_F(WebCryptoAesCbcTest, ImportKeyJwkKeyOpsEncryptDecrypt) {
   blink::WebCryptoKey key;
   base::DictionaryValue dict;
   dict.SetString("kty", "oct");
   dict.SetString("k", "GADWrMRHwQfoNaXU5fZvTg");
-  base::ListValue* key_ops = new base::ListValue;
-  dict.Set("key_ops", key_ops);  // Takes ownership.
+  base::ListValue* key_ops =
+      dict.SetList("key_ops", base::MakeUnique<base::ListValue>());
 
   key_ops->AppendString("encrypt");
 
   EXPECT_EQ(Status::Success(),
             ImportKeyJwkFromDict(
                 dict, CreateAlgorithm(blink::kWebCryptoAlgorithmIdAesCbc),
                 false, blink::kWebCryptoKeyUsageEncrypt, &key));
 
   EXPECT_EQ(blink::kWebCryptoKeyUsageEncrypt, key.Usages());
 
@@ skipping 16 matching lines @@
   EXPECT_EQ(blink::kWebCryptoKeyUsageEncrypt | blink::kWebCryptoKeyUsageDecrypt,
             key.Usages());
 }
 
 // Test failure if input usage is NOT a strict subset of the JWK usage.
 TEST_F(WebCryptoAesCbcTest, ImportKeyJwkKeyOpsNotSuperset) {
   blink::WebCryptoKey key;
   base::DictionaryValue dict;
   dict.SetString("kty", "oct");
   dict.SetString("k", "GADWrMRHwQfoNaXU5fZvTg");
-  base::ListValue* key_ops = new base::ListValue;
-  dict.Set("key_ops", key_ops);  // Takes ownership.
-
+  auto key_ops = base::MakeUnique<base::ListValue>();
   key_ops->AppendString("encrypt");
+  dict.Set("key_ops", std::move(key_ops));
 
   EXPECT_EQ(
       Status::ErrorJwkKeyopsInconsistent(),
       ImportKeyJwkFromDict(
           dict, CreateAlgorithm(blink::kWebCryptoAlgorithmIdAesCbc), false,
           blink::kWebCryptoKeyUsageEncrypt | blink::kWebCryptoKeyUsageDecrypt,
           &key));
 }
 
 TEST_F(WebCryptoAesCbcTest, ImportKeyJwkUseEnc) {
@@ skipping 42 matching lines @@
 
 // Fail on inconsistent key_ops - asking for "encrypt" however JWK contains
 // only "foo".
 TEST_F(WebCryptoAesCbcTest, ImportJwkKeyOpsLacksUsages) {
   blink::WebCryptoKey key;
 
   base::DictionaryValue dict;
   dict.SetString("kty", "oct");
   dict.SetString("k", "GADWrMRHwQfoNaXU5fZvTg");
 
-  base::ListValue* key_ops = new base::ListValue;
-  // Note: the following call makes dict assume ownership of key_ops.
-  dict.Set("key_ops", key_ops);
+  auto key_ops = base::MakeUnique<base::ListValue>();
   key_ops->AppendString("foo");
+  dict.Set("key_ops", std::move(key_ops));
   EXPECT_EQ(Status::ErrorJwkKeyopsInconsistent(),
             ImportKeyJwkFromDict(
                 dict, CreateAlgorithm(blink::kWebCryptoAlgorithmIdAesCbc),
                 false, blink::kWebCryptoKeyUsageEncrypt, &key));
 }
 
 TEST_F(WebCryptoAesCbcTest, ImportExportJwk) {
   const blink::WebCryptoAlgorithm algorithm =
       CreateAlgorithm(blink::kWebCryptoAlgorithmIdAesCbc);
 
@@ skipping 180 matching lines @@
   EXPECT_EQ(public_key_spki, unwrapped_public_key_spki);
   EXPECT_EQ(private_key_pkcs8, unwrapped_private_key_pkcs8);
 
   EXPECT_NE(public_key_spki, wrapped_public_key);
   EXPECT_NE(private_key_pkcs8, wrapped_private_key);
 }
 
 }  // namespace
 
 }  // namespace webcrypto