components/autofill: scoped_ptr -> unique_ptr

components/autofill/content/renderer/password_form_conversion_utils_browsertest.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 <stddef.h>
 
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 153 matching lines @@
  public:
   MAYBE_PasswordFormConversionUtilsTest() : content::RenderViewTest() {}
   ~MAYBE_PasswordFormConversionUtilsTest() override {}
 
  protected:
   // Loads the given |html|, retrieves the sole WebFormElement from it, and then
   // calls CreatePasswordForm(), passing it the |predictions| to convert it into
   // a |password_form|. Note that ASSERT() can only be used in void functions,
   // this is why |password_form| is passed in as a pointer to a scoped_ptr.
   void LoadHTMLAndConvertForm(const std::string& html,
-                              scoped_ptr<PasswordForm>* password_form,
+                              std::unique_ptr<PasswordForm>* password_form,
                               FormsPredictionsMap* predictions) {
     WebFormElement form;
     LoadWebFormFromHTML(html, &form);
 
     WebVector<WebFormControlElement> control_elements;
     form.getFormControlElements(control_elements);
     for (size_t i = 0; i < control_elements.size(); ++i) {
       WebInputElement* input_element = toWebInputElement(&control_elements[i]);
       if (input_element->hasAttribute("set-activated-submit"))
         input_element->setActivatedSubmit(true);
@@ skipping 52 matching lines @@
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, BasicFormAttributes) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("username", "johnsmith", NULL);
   builder.AddSubmitButton("inactive_submit");
   builder.AddSubmitButton("active_submit");
   builder.AddSubmitButton("inactive_submit2");
   builder.AddPasswordField("password", "secret", NULL);
   std::string html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(html, &password_form, nullptr));
   ASSERT_TRUE(password_form);
 
   EXPECT_EQ("data:", password_form->signon_realm);
   EXPECT_EQ(GURL(kTestFormActionURL), password_form->action);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("johnsmith"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->password_value);
   EXPECT_EQ(PasswordForm::SCHEME_HTML, password_form->scheme);
   EXPECT_FALSE(password_form->ssl_valid);
   EXPECT_FALSE(password_form->preferred);
   EXPECT_FALSE(password_form->blacklisted_by_user);
   EXPECT_EQ(PasswordForm::TYPE_MANUAL, password_form->type);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, DisabledFieldsAreIgnored) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("username", "johnsmith", NULL);
   builder.AddDisabledUsernameField();
   builder.AddDisabledPasswordField();
   builder.AddPasswordField("password", "secret", NULL);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(html, &password_form, nullptr));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("johnsmith"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->password_value);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, IdentifyingUsernameFields) {
@@ skipping 50 matching lines @@
 
       PasswordFormBuilder builder(kTestFormActionURL);
       builder.AddTextField("username1", names[0], cases[i].autocomplete[0]);
       builder.AddTextField("username2", names[1], cases[i].autocomplete[1]);
       builder.AddPasswordField("password", "secret", NULL);
       builder.AddTextField("username3", names[2], cases[i].autocomplete[2]);
       builder.AddPasswordField("password2", "othersecret", NULL);
       builder.AddSubmitButton("submit");
       std::string html = builder.ProduceHTML();
 
-      scoped_ptr<PasswordForm> password_form;
+      std::unique_ptr<PasswordForm> password_form;
       ASSERT_NO_FATAL_FAILURE(
           LoadHTMLAndConvertForm(html, &password_form, nullptr));
       ASSERT_TRUE(password_form);
 
       EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_username_element),
                 password_form->username_element);
 
       if (nonempty_username_fields) {
         EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_username_value),
                   password_form->username_value);
@@ skipping 39 matching lines @@
     SCOPED_TRACE(testing::Message() << "Iteration " << i);
 
     PasswordFormBuilder builder(kTestFormActionURL);
     builder.AddTextField("username1", "William", NULL);
     builder.AddPasswordField("password1", cases[i].password_values[0], NULL);
     builder.AddTextField("username2", "Smith", NULL);
     builder.AddPasswordField("password2", cases[i].password_values[1], NULL);
     builder.AddSubmitButton("submit");
     std::string html = builder.ProduceHTML();
 
-    scoped_ptr<PasswordForm> password_form;
+    std::unique_ptr<PasswordForm> password_form;
     ASSERT_NO_FATAL_FAILURE(
         LoadHTMLAndConvertForm(html, &password_form, nullptr));
     ASSERT_TRUE(password_form);
 
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_password_element),
               password_form->password_element);
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_password_value),
               password_form->password_value);
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_new_password_element),
               password_form->new_password_element);
@@ skipping 41 matching lines @@
 
     PasswordFormBuilder builder(kTestFormActionURL);
     builder.AddTextField("username1", "William", NULL);
     builder.AddPasswordField("password1", cases[i].password_values[0], NULL);
     builder.AddPasswordField("password2", cases[i].password_values[1], NULL);
     builder.AddTextField("username2", "Smith", NULL);
     builder.AddPasswordField("password3", cases[i].password_values[2], NULL);
     builder.AddSubmitButton("submit");
     std::string html = builder.ProduceHTML();
 
-    scoped_ptr<PasswordForm> password_form;
+    std::unique_ptr<PasswordForm> password_form;
     ASSERT_NO_FATAL_FAILURE(
         LoadHTMLAndConvertForm(html, &password_form, nullptr));
     ASSERT_TRUE(password_form);
 
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_password_element),
               password_form->password_element);
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_password_value),
               password_form->password_value);
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_new_password_element),
               password_form->new_password_element);
@@ skipping 120 matching lines @@
     builder.AddPasswordField("pin1", "123456", NULL);
     builder.AddPasswordField("pin2", "789101", NULL);
     builder.AddTextField("username1", "William", NULL);
     builder.AddPasswordField("password1", "alpha", cases[i].autocomplete[0]);
     builder.AddTextField("username2", "Smith", NULL);
     builder.AddPasswordField("password2", "beta", cases[i].autocomplete[1]);
     builder.AddPasswordField("password3", "gamma", cases[i].autocomplete[2]);
     builder.AddSubmitButton("submit");
     std::string html = builder.ProduceHTML();
 
-    scoped_ptr<PasswordForm> password_form;
+    std::unique_ptr<PasswordForm> password_form;
     ASSERT_NO_FATAL_FAILURE(
         LoadHTMLAndConvertForm(html, &password_form, nullptr));
     ASSERT_TRUE(password_form);
 
     // In the absence of username autocomplete attributes, the username should
     // be the text input field just before 'current-password' or before
     // 'new-password', if there is no 'current-password'.
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_username_element),
               password_form->username_element);
     EXPECT_EQ(base::UTF8ToUTF16(cases[i].expected_username_value),
@@ skipping 22 matching lines @@
   PasswordFormBuilder builder(kTestFormActionURL);
 
   builder.AddNonDisplayedTextField("nondisplayed1", "nodispalyed_value1");
   builder.AddTextField("username", "johnsmith", NULL);
   builder.AddNonDisplayedTextField("nondisplayed2", "nodispalyed_value2");
   builder.AddPasswordField("password", "secret", NULL);
   builder.AddPasswordField("password", "secret", NULL);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(html, &password_form, nullptr));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("johnsmith"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16(""), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->new_password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->new_password_value);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, IgnoreNonDisplayedLoginPairs) {
   PasswordFormBuilder builder(kTestFormActionURL);
 
   builder.AddNonDisplayedTextField("nondisplayed1", "nodispalyed_value1");
   builder.AddNonDisplayedPasswordField("nondisplayed2", "nodispalyed_value2");
   builder.AddTextField("username", "johnsmith", NULL);
   builder.AddNonDisplayedTextField("nondisplayed3", "nodispalyed_value3");
   builder.AddNonDisplayedPasswordField("nondisplayed4", "nodispalyed_value4");
   builder.AddPasswordField("password", "secret", NULL);
   builder.AddPasswordField("password", "secret", NULL);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(html, &password_form, nullptr));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("johnsmith"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16(""), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->new_password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->new_password_value);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, OnlyNonDisplayedLoginPair) {
   PasswordFormBuilder builder(kTestFormActionURL);
 
   builder.AddNonDisplayedTextField("username", "William");
   builder.AddNonDisplayedPasswordField("password", "secret");
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(html, &password_form, nullptr));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"),
             password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("William"),
             password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16("password"),
             password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"),
             password_form->password_value);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        VisiblePasswordAndInvisibleUsername) {
   PasswordFormBuilder builder(kTestFormActionURL);
 
   builder.AddNonDisplayedTextField("username", "William");
   builder.AddPasswordField("password", "secret", NULL);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(html, &password_form, nullptr));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("William"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->password_value);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        InvisiblePassword_LatestUsernameIsVisible) {
   PasswordFormBuilder builder(kTestFormActionURL);
 
   builder.AddNonDisplayedTextField("search", "query");
   builder.AddTextField("username", "William", NULL);
   builder.AddNonDisplayedPasswordField("password", "secret");
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(html, &password_form, nullptr));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("William"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->password_value);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        InvisiblePassword_LatestUsernameIsInvisible) {
   PasswordFormBuilder builder(kTestFormActionURL);
 
   builder.AddTextField("search", "query", NULL);
   builder.AddNonDisplayedTextField("username", "William");
   builder.AddNonDisplayedPasswordField("password", "secret");
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(html, &password_form, nullptr));
   ASSERT_TRUE(password_form);
   EXPECT_EQ(base::UTF8ToUTF16("username"), password_form->username_element);
   EXPECT_EQ(base::UTF8ToUTF16("William"), password_form->username_value);
   EXPECT_EQ(base::UTF8ToUTF16("password"), password_form->password_element);
   EXPECT_EQ(base::UTF8ToUTF16("secret"), password_form->password_value);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, InvalidFormDueToBadActionURL) {
   PasswordFormBuilder builder("invalid_target");
   builder.AddTextField("username", "JohnSmith", NULL);
   builder.AddSubmitButton("submit");
   builder.AddPasswordField("password", "secret", NULL);
   std::string html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(html, &password_form, nullptr));
   EXPECT_FALSE(password_form);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        InvalidFormDueToNoPasswordFields) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("username1", "John", NULL);
   builder.AddTextField("username2", "Smith", NULL);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(html, &password_form, nullptr));
   EXPECT_FALSE(password_form);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        InvalidFormsDueToConfusingPasswordFields) {
   // Each test case consists of a set of parameters to be plugged into the
   // PasswordFormBuilder below.
   const char* cases[][3] = {
@@ skipping 10 matching lines @@
     SCOPED_TRACE(testing::Message() << "Iteration " << i);
 
     PasswordFormBuilder builder(kTestFormActionURL);
     builder.AddTextField("username1", "John", NULL);
     builder.AddPasswordField("password1", cases[i][0], NULL);
     builder.AddPasswordField("password2", cases[i][1], NULL);
     builder.AddPasswordField("password3", cases[i][2], NULL);
     builder.AddSubmitButton("submit");
     std::string html = builder.ProduceHTML();
 
-    scoped_ptr<PasswordForm> password_form;
+    std::unique_ptr<PasswordForm> password_form;
     ASSERT_NO_FATAL_FAILURE(
         LoadHTMLAndConvertForm(html, &password_form, nullptr));
     EXPECT_FALSE(password_form);
   }
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        InvalidFormDueToTooManyPasswordFieldsWithoutAutocompleteAttributes) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("username1", "John", NULL);
   builder.AddPasswordField("password1", "alpha", NULL);
   builder.AddPasswordField("password2", "alpha", NULL);
   builder.AddPasswordField("password3", "alpha", NULL);
   builder.AddPasswordField("password4", "alpha", NULL);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(html, &password_form, nullptr));
   EXPECT_FALSE(password_form);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, LayoutClassificationLogin) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddHiddenField();
   builder.AddTextField("username", "", nullptr);
   builder.AddPasswordField("password", "", nullptr);
   builder.AddSubmitButton("submit");
   std::string login_html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> login_form;
+  std::unique_ptr<PasswordForm> login_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(login_html, &login_form, nullptr));
   ASSERT_TRUE(login_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_OTHER, login_form->layout);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, LayoutClassificationSignup) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("someotherfield", "", nullptr);
   builder.AddTextField("username", "", nullptr);
   builder.AddPasswordField("new_password", "", nullptr);
   builder.AddHiddenField();
   builder.AddPasswordField("new_password2", "", nullptr);
   builder.AddSubmitButton("submit");
   std::string signup_html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> signup_form;
+  std::unique_ptr<PasswordForm> signup_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(signup_html, &signup_form, nullptr));
   ASSERT_TRUE(signup_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_OTHER, signup_form->layout);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, LayoutClassificationChange) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("username", "", nullptr);
   builder.AddPasswordField("old_password", "", nullptr);
   builder.AddHiddenField();
   builder.AddPasswordField("new_password", "", nullptr);
   builder.AddPasswordField("new_password2", "", nullptr);
   builder.AddSubmitButton("submit");
   std::string change_html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> change_form;
+  std::unique_ptr<PasswordForm> change_form;
   ASSERT_NO_FATAL_FAILURE(
       LoadHTMLAndConvertForm(change_html, &change_form, nullptr));
   ASSERT_TRUE(change_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_OTHER, change_form->layout);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        LayoutClassificationLoginPlusSignup_A) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("username", "", nullptr);
   builder.AddHiddenField();
   builder.AddPasswordField("password", "", nullptr);
   builder.AddTextField("username2", "", nullptr);
   builder.AddTextField("someotherfield", "", nullptr);
   builder.AddPasswordField("new_password", "", nullptr);
   builder.AddPasswordField("new_password2", "", nullptr);
   builder.AddHiddenField();
   builder.AddSubmitButton("submit");
   std::string login_plus_signup_html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> login_plus_signup_form;
+  std::unique_ptr<PasswordForm> login_plus_signup_form;
   ASSERT_NO_FATAL_FAILURE(LoadHTMLAndConvertForm(
       login_plus_signup_html, &login_plus_signup_form, nullptr));
   ASSERT_TRUE(login_plus_signup_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_LOGIN_AND_SIGNUP,
             login_plus_signup_form->layout);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        LayoutClassificationLoginPlusSignup_B) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("username", "", nullptr);
   builder.AddHiddenField();
   builder.AddPasswordField("password", "", nullptr);
   builder.AddTextField("username2", "", nullptr);
   builder.AddTextField("someotherfield", "", nullptr);
   builder.AddPasswordField("new_password", "", nullptr);
   builder.AddTextField("someotherfield2", "", nullptr);
   builder.AddHiddenField();
   builder.AddSubmitButton("submit");
   std::string login_plus_signup_html = builder.ProduceHTML();
 
-  scoped_ptr<PasswordForm> login_plus_signup_form;
+  std::unique_ptr<PasswordForm> login_plus_signup_form;
   ASSERT_NO_FATAL_FAILURE(LoadHTMLAndConvertForm(
       login_plus_signup_html, &login_plus_signup_form, nullptr));
   ASSERT_TRUE(login_plus_signup_form);
   EXPECT_EQ(PasswordForm::Layout::LAYOUT_LOGIN_AND_SIGNUP,
             login_plus_signup_form->layout);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        CreditCardNumberWithTypePasswordForm) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("Credit card owner name", "John Smith", nullptr);
   builder.AddPasswordField("Credit card number", "0000 0000 0000 0000",
                            nullptr);
   builder.AddTextField("cvc", "000", nullptr);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::map<int, PasswordFormFieldPredictionType> predictions_positions;
   predictions_positions[1] = PREDICTION_NOT_PASSWORD;
 
   FormsPredictionsMap predictions;
   SetPredictions(html, &predictions, predictions_positions);
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   LoadHTMLAndConvertForm(html, &password_form, &predictions);
   EXPECT_FALSE(password_form);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        CreditCardVerificationNumberWithTypePasswordForm) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("Credit card owner name", "John Smith", nullptr);
   builder.AddTextField("Credit card number", "0000 0000 0000 0000", nullptr);
   builder.AddPasswordField("cvc", "000", nullptr);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::map<int, PasswordFormFieldPredictionType> predictions_positions;
   predictions_positions[2] = PREDICTION_NOT_PASSWORD;
 
   FormsPredictionsMap predictions;
   SetPredictions(html, &predictions, predictions_positions);
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   LoadHTMLAndConvertForm(html, &password_form, &predictions);
   EXPECT_FALSE(password_form);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        CreditCardNumberWithTypePasswordFormWithAutocomplete) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("Credit card owner name", "John Smith", nullptr);
   builder.AddPasswordField("Credit card number", "0000 0000 0000 0000",
                            "current-password");
   builder.AddTextField("cvc", "000", nullptr);
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::map<int, PasswordFormFieldPredictionType> predictions_positions;
   predictions_positions[1] = PREDICTION_NOT_PASSWORD;
 
   FormsPredictionsMap predictions;
   SetPredictions(html, &predictions, predictions_positions);
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   LoadHTMLAndConvertForm(html, &password_form, &predictions);
   EXPECT_TRUE(password_form);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest,
        CreditCardVerificationNumberWithTypePasswordFormWithAutocomplete) {
   PasswordFormBuilder builder(kTestFormActionURL);
   builder.AddTextField("Credit card owner name", "John Smith", nullptr);
   builder.AddTextField("Credit card number", "0000 0000 0000 0000", nullptr);
   builder.AddPasswordField("cvc", "000", "new-password");
   builder.AddSubmitButton("submit");
   std::string html = builder.ProduceHTML();
 
   std::map<int, PasswordFormFieldPredictionType> predictions_positions;
   predictions_positions[2] = PREDICTION_NOT_PASSWORD;
 
   FormsPredictionsMap predictions;
   SetPredictions(html, &predictions, predictions_positions);
 
-  scoped_ptr<PasswordForm> password_form;
+  std::unique_ptr<PasswordForm> password_form;
   LoadHTMLAndConvertForm(html, &password_form, &predictions);
   EXPECT_TRUE(password_form);
 }
 
 TEST_F(MAYBE_PasswordFormConversionUtilsTest, IsGaiaReauthFormIgnored) {
   struct TestCase {
     const char* origin;
     struct KeyValue {
       KeyValue() : name(nullptr), value(nullptr) {}
       KeyValue(const char* new_name, const char* new_value)
@@ skipping 72 matching lines @@
 
   for (TestCase& test_case : cases) {
     SCOPED_TRACE(testing::Message("origin=")
                  << test_case.origin
                  << ", hidden_fields[0]=" << test_case.hidden_fields[0].name
                  << "/" << test_case.hidden_fields[0].value
                  << ", hidden_fields[1]=" << test_case.hidden_fields[1].name
                  << "/" << test_case.hidden_fields[1].value
                  << ", expected_form_is_reauth="
                  << test_case.expected_form_is_reauth);
-    scoped_ptr<PasswordFormBuilder> builder(new PasswordFormBuilder(""));
+    std::unique_ptr<PasswordFormBuilder> builder(new PasswordFormBuilder(""));
     builder->AddTextField("username", "", nullptr);
     builder->AddPasswordField("password", "", nullptr);
     for (TestCase::KeyValue& hidden_field : test_case.hidden_fields) {
       if (hidden_field.name)
         builder->AddHiddenField(hidden_field.name, hidden_field.value);
     }
     std::string html = builder->ProduceHTML();
     WebFormElement form;
     LoadWebFormFromHTML(html, &form);
     std::vector<WebFormControlElement> control_elements;
@@ skipping 51 matching lines @@
     }
 
     if (test_cases[i].new_password_fieldname == kEmpty) {
       builder.AddAnonymousInputField("password");
     } else {
       builder.AddPasswordField(test_cases[i].new_password_fieldname, "",
                                kEmpty);
     }
     std::string html = builder.ProduceHTML();
 
-    scoped_ptr<PasswordForm> password_form;
+    std::unique_ptr<PasswordForm> password_form;
     LoadHTMLAndConvertForm(html, &password_form, nullptr);
     EXPECT_TRUE(password_form);
 
     EXPECT_EQ(base::UTF8ToUTF16(test_cases[i].expected_username_element),
               password_form->username_element);
     EXPECT_EQ(base::UTF8ToUTF16(test_cases[i].expected_password_element),
               password_form->password_element);
     EXPECT_EQ(base::UTF8ToUTF16(test_cases[i].expected_new_password_element),
               password_form->new_password_element);
   }
 }
 
 }  // namespace autofill