Convert //ios from scoped_ptr to std::unique_ptr.

ios/web/web_state/js/credential_util_unittest.mm

 // Copyright 2015 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 "ios/web/public/web_state/js/credential_util.h"
 
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "ios/web/public/web_state/credential.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gtest_mac.h"
 #include "testing/platform_test.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
@@ skipping 39 matching lines @@
   credential.id = base::ASCIIToUTF16(kTestCredentialID);
   credential.name = base::ASCIIToUTF16(kTestCredentialName);
   credential.avatar_url = GURL(kTestCredentialAvatarURL);
   credential.federation_origin =
       url::Origin(GURL(kTestCredentialFederationURL));
   return credential;
 }
 
 // Returns a value representing the credential returned by
 // |GetTestPasswordCredential()|.
-scoped_ptr<base::DictionaryValue> GetTestPasswordCredentialDictionaryValue() {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+std::unique_ptr<base::DictionaryValue>
+GetTestPasswordCredentialDictionaryValue() {
+  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue);
   value->SetString("type", kTestCredentialTypePassword);
   value->SetString("id", kTestCredentialID);
   value->SetString("name", kTestCredentialName);
   value->SetString("avatarURL", kTestCredentialAvatarURL);
   value->SetString("password", kTestCredentialPassword);
   return value;
 }
 
 // Returns a value representing the credential returned by
 // |GetTestFederatedCredentialDictionaryValue()|.
-scoped_ptr<base::DictionaryValue> GetTestFederatedCredentialDictionaryValue() {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+std::unique_ptr<base::DictionaryValue>
+GetTestFederatedCredentialDictionaryValue() {
+  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue);
   value->SetString("type", kTestCredentialTypeFederated);
   value->SetString("id", kTestCredentialID);
   value->SetString("name", kTestCredentialName);
   value->SetString("avatarURL", kTestCredentialAvatarURL);
   value->SetString("federation",
                    url::Origin(GURL(kTestCredentialFederationURL)).Serialize());
   return value;
 }
 
 // Tests that parsing an empty value fails.
 TEST(CredentialUtilTest, ParsingEmptyValueFails) {
   base::DictionaryValue value;
   Credential credential;
   EXPECT_FALSE(DictionaryValueToCredential(value, &credential));
 }
 
 // Tests that parsing a value with a bad type fails.
 TEST(CredentialUtilTest, ParsingValueWithBadTypeFails) {
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue);
   value->SetString("type", "FooCredential");
   Credential credential;
   EXPECT_FALSE(DictionaryValueToCredential(*value, &credential));
 }
 
 // Tests that parsing a correctly-formed value representing a PasswordCredential
 // succeeds.
 TEST(CredentialUtilTest, ParsingPasswordCredentialSucceeds) {
   Credential credential;
   EXPECT_TRUE(DictionaryValueToCredential(
       *GetTestPasswordCredentialDictionaryValue(), &credential));
   EXPECT_TRUE(CredentialsEqual(GetTestPasswordCredential(), credential));
 }
 
 // Tests that parsing a value representing a PasswordCredential but with no ID
 // specified fails.
 TEST(CredentialUtilTest, ParsingPasswordCredentialWithNoIDFails) {
-  scoped_ptr<base::DictionaryValue> value(
+  std::unique_ptr<base::DictionaryValue> value(
       GetTestPasswordCredentialDictionaryValue());
   value->RemoveWithoutPathExpansion("id", nullptr);
   Credential credential;
   EXPECT_FALSE(DictionaryValueToCredential(*value, &credential));
 }
 
 // Tests that parsing a value representing a PasswordCredential with a badly-
 // formed avatarURL fails.
 TEST(CredentialUtilTest, ParsingPasswordCredentialWithBadAvatarURLFails) {
-  scoped_ptr<base::DictionaryValue> value(
+  std::unique_ptr<base::DictionaryValue> value(
       GetTestPasswordCredentialDictionaryValue());
   value->SetString("avatarURL", "foo");
   Credential credential;
   EXPECT_FALSE(DictionaryValueToCredential(*value, &credential));
 }
 
 // Tests that parsing a value representing a PasswordCredential with no password
 // specified fails.
 TEST(CredentialUtilTest, ParsingPasswordCredentialWithNoPasswordFails) {
-  scoped_ptr<base::DictionaryValue> value(
+  std::unique_ptr<base::DictionaryValue> value(
       GetTestPasswordCredentialDictionaryValue());
   value->Remove("password", nullptr);
   Credential credential;
   EXPECT_FALSE(DictionaryValueToCredential(*value, &credential));
 }
 
 // Tests that parsing a correctly-formed value representing a
 // FederatedCredential succeeds.
 TEST(CredentialUtilTest, ParsingFederatedCredentialSucceeds) {
   Credential credential;
   EXPECT_TRUE(DictionaryValueToCredential(
       *GetTestFederatedCredentialDictionaryValue(), &credential));
   EXPECT_TRUE(CredentialsEqual(GetTestFederatedCredential(), credential));
 }
 
 // Tests that parsing a value representing a FederatedCredential with no ID
 // fails.
 TEST(CredentialUtilTest, ParsingFederatedCredentialWithNoIDFails) {
-  scoped_ptr<base::DictionaryValue> value(
+  std::unique_ptr<base::DictionaryValue> value(
       GetTestFederatedCredentialDictionaryValue());
   value->RemoveWithoutPathExpansion("id", nullptr);
   Credential credential;
   EXPECT_FALSE(DictionaryValueToCredential(*value, &credential));
 }
 
 // Tests that parsing a value representing a FederatedCredential with a badly-
 // formed avatarURL fails.
 TEST(CredentialUtilTest, ParsingFederatedCredentialWithBadAvatarURLFails) {
-  scoped_ptr<base::DictionaryValue> value(
+  std::unique_ptr<base::DictionaryValue> value(
       GetTestFederatedCredentialDictionaryValue());
   value->SetString("avatarURL", "foo");
   Credential credential;
   EXPECT_FALSE(DictionaryValueToCredential(*value, &credential));
 }
 
 // Tests that parsing a value representing a FederatedCredential with no
 // federation URL fails.
 TEST(CredentialUtilTest, ParsingFederatedValueWithNoFederationURLFails) {
-  scoped_ptr<base::DictionaryValue> value(
+  std::unique_ptr<base::DictionaryValue> value(
       GetTestFederatedCredentialDictionaryValue());
   value->Remove("federation", nullptr);
   Credential credential;
   EXPECT_FALSE(DictionaryValueToCredential(*value, &credential));
 }
 
 // Tests that parsing a value representing a FederatedCredential with a badly-
 // formed federationURL fails.
 TEST(CredentialUtilTest, ParsingFederatedValueWithBadFederationURLFails) {
-  scoped_ptr<base::DictionaryValue> value(
+  std::unique_ptr<base::DictionaryValue> value(
       GetTestFederatedCredentialDictionaryValue());
   value->SetString("federation", "bar");
   Credential credential;
   EXPECT_FALSE(DictionaryValueToCredential(*value, &credential));
 }
 
 // Tests that serializing a FederatedCredential to a DictionaryValue results
 // in the expected structure.
 TEST(CredentialUtilTest, SerializeFederatedCredential) {
   base::DictionaryValue value;
   Credential credential(GetTestFederatedCredential());
   CredentialToDictionaryValue(credential, &value);
   EXPECT_TRUE(GetTestFederatedCredentialDictionaryValue()->Equals(&value));
 }
 
 // Tests that serializing a PasswordCredential to a DictionaryValue results in
 // the
 // expected structure.
 TEST(CredentialUtilTest, SerializePasswordCredential) {
   base::DictionaryValue value;
   Credential credential(GetTestPasswordCredential());
   CredentialToDictionaryValue(credential, &value);
   EXPECT_TRUE(GetTestPasswordCredentialDictionaryValue()->Equals(&value));
 }
 
 TEST(CredentialUtilTest, SerializeEmptyCredential) {
   base::DictionaryValue value;
   Credential credential;
   CredentialToDictionaryValue(credential, &value);
-  EXPECT_TRUE(make_scoped_ptr(new base::DictionaryValue)->Equals(&value));
+  EXPECT_TRUE(base::WrapUnique(new base::DictionaryValue)->Equals(&value));
 }
 
 TEST(CredentialUtilTest, SerializeEmptyCredentialIntoNonEmptyDictionary) {
   base::DictionaryValue value;
   value.SetString("foo", "bar");
   Credential credential;
   CredentialToDictionaryValue(credential, &value);
-  EXPECT_TRUE(make_scoped_ptr(new base::DictionaryValue)->Equals(&value));
+  EXPECT_TRUE(base::WrapUnique(new base::DictionaryValue)->Equals(&value));
 }
 
 }  // namespace
 }  // namespace web