components/autofill: scoped_ptr -> unique_ptr

components/autofill/core/browser/form_structure_unittest.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 "components/autofill/core/browser/form_structure.h"
 
 #include <stddef.h>
 
+#include <memory>
+
 #include "base/command_line.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/variations/entropy_provider.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 44 matching lines @@
  private:
   void EnableAutofillMetadataFieldTrial() {
     field_trial_list_.reset();
     field_trial_list_.reset(
         new base::FieldTrialList(new metrics::SHA1EntropyProvider("foo")));
     field_trial_ = base::FieldTrialList::CreateFieldTrial(
         "AutofillFieldMetadata", "Enabled");
     field_trial_->group();
   }
 
-  scoped_ptr<base::FieldTrialList> field_trial_list_;
+  std::unique_ptr<base::FieldTrialList> field_trial_list_;
   scoped_refptr<base::FieldTrial> field_trial_;
 };
 
 TEST_F(FormStructureTest, FieldCount) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.label = ASCIIToUTF16("username");
   field.name = ASCIIToUTF16("username");
   field.form_control_type = "text";
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("password");
   field.name = ASCIIToUTF16("password");
@@ skipping 11 matching lines @@
   field.should_autocomplete = false;
   form.fields.push_back(field);
 
   // The render process sends all fields to browser including fields with
   // autocomplete=off
   form_structure.reset(new FormStructure(form));
   EXPECT_EQ(4U, form_structure->field_count());
 }
 
 TEST_F(FormStructureTest, AutofillCount) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.label = ASCIIToUTF16("username");
   field.name = ASCIIToUTF16("username");
   field.form_control_type = "text";
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("password");
   field.name = ASCIIToUTF16("password");
@@ skipping 40 matching lines @@
 
 TEST_F(FormStructureTest, SourceURL) {
   FormData form;
   form.origin = GURL("http://www.foo.com/");
   FormStructure form_structure(form);
 
   EXPECT_EQ(form.origin, form_structure.source_url());
 }
 
 TEST_F(FormStructureTest, IsAutofillable) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   // We need at least three text fields to be auto-fillable.
   FormFieldData field;
 
   field.label = ASCIIToUTF16("username");
   field.name = ASCIIToUTF16("username");
   field.form_control_type = "text";
   form.fields.push_back(field);
 
@@ skipping 43 matching lines @@
   EXPECT_FALSE(form_structure->IsAutofillable());
 
   // But search can be in the URL.
   form.action = GURL("http://search.com/?q=hello");
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
   EXPECT_TRUE(form_structure->IsAutofillable());
 }
 
 TEST_F(FormStructureTest, ShouldBeParsed) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   // We need at least three text fields to be parseable.
   FormFieldData field;
   field.label = ASCIIToUTF16("username");
   field.name = ASCIIToUTF16("username");
   field.form_control_type = "text";
   form.fields.push_back(field);
 
   FormFieldData checkable_field;
@@ skipping 80 matching lines @@
   field.name = ASCIIToUTF16("new_pw");
   field.form_control_type = "password";
   form.fields.push_back(field);
   form_structure.reset(new FormStructure(form));
   EXPECT_TRUE(form_structure->ShouldBeParsed());
 }
 
 // Tests that ShouldBeParsed returns true for a form containing less than three
 // fields if at least one has an autocomplete attribute.
 TEST_F(FormStructureTest, ShouldBeParsed_TwoFields_HasAutocomplete) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
   FormFieldData field;
 
   field.label = ASCIIToUTF16("Name");
   field.name = ASCIIToUTF16("name");
   field.form_control_type = "name";
   field.autocomplete_attribute = "name";
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Address");
   field.name = ASCIIToUTF16("Address");
   field.form_control_type = "select-one";
   field.autocomplete_attribute = "";
   form.fields.push_back(field);
 
   form_structure.reset(new FormStructure(form));
   form_structure->ParseFieldTypesFromAutocompleteAttributes();
   EXPECT_TRUE(form_structure->ShouldBeParsed());
 }
 
 TEST_F(FormStructureTest, HeuristicsContactInfo) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Last Name");
@@ skipping 53 matching lines @@
   // City.
   EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(6)->heuristic_type());
   // Zip.
   EXPECT_EQ(ADDRESS_HOME_ZIP, form_structure->field(7)->heuristic_type());
   // Submit.
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(8)->heuristic_type());
 }
 
 // Verify that we can correctly process the |autocomplete| attribute.
 TEST_F(FormStructureTest, HeuristicsAutocompleteAttribute) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = base::string16();
   field.name = ASCIIToUTF16("field1");
   field.autocomplete_attribute = "given-name";
   form.fields.push_back(field);
 
@@ skipping 18 matching lines @@
   EXPECT_EQ(HTML_TYPE_GIVEN_NAME, form_structure->field(0)->html_type());
   EXPECT_EQ(HTML_TYPE_FAMILY_NAME, form_structure->field(1)->html_type());
   EXPECT_EQ(HTML_TYPE_EMAIL, form_structure->field(2)->html_type());
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(0)->heuristic_type());
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(1)->heuristic_type());
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(2)->heuristic_type());
 }
 
 // Verify that the heuristics are not run for non checkout formless forms.
 TEST_F(FormStructureTest, Heuristics_FormlessNonCheckoutForm) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name:");
   field.name = ASCIIToUTF16("firstname");
   field.autocomplete_attribute = "given-name";
   form.fields.push_back(field);
 
@@ skipping 57 matching lines @@
 
   field.label = ASCIIToUTF16("Phone");
   field.name = ASCIIToUTF16("ctl01$ctl00$ShippingAddressCreditPhone$phone");
   form.fields.push_back(field);
 
   field.label = base::string16();
   field.name = ASCIIToUTF16("ctl01$ctl00$ShippingAddressCreditPhone$submit");
   field.form_control_type = "submit";
   form.fields.push_back(field);
 
-  scoped_ptr<FormStructure> form_structure(new FormStructure(form));
+  std::unique_ptr<FormStructure> form_structure(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
   EXPECT_TRUE(form_structure->IsAutofillable());
 
   // Expect the correct number of fields.
   ASSERT_EQ(5U, form_structure->field_count());
   ASSERT_EQ(4U, form_structure->autofill_count());
 
   // First name.
   EXPECT_EQ(NAME_FIRST, form_structure->field(0)->heuristic_type());
   // Last name.
@@ skipping 19 matching lines @@
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Address 2");
   field.name = ASCIIToUTF16("address2");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Address 3");
   field.name = ASCIIToUTF16("address3");
   form.fields.push_back(field);
 
-  scoped_ptr<FormStructure> form_structure(new FormStructure(form));
+  std::unique_ptr<FormStructure> form_structure(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
   EXPECT_TRUE(form_structure->IsAutofillable());
 
   // Expect the correct number of fields.
   ASSERT_EQ(3U, form_structure->field_count());
   ASSERT_EQ(3U, form_structure->autofill_count());
 
   // Address 1.
   EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(0)->heuristic_type());
   // Address 2.
   EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(1)->heuristic_type());
   // Address 3
   EXPECT_EQ(ADDRESS_HOME_LINE3, form_structure->field(2)->heuristic_type());
 }
 
 // Verify that we can correctly process the 'autocomplete' attribute for phone
 // number types (especially phone prefixes and suffixes).
 TEST_F(FormStructureTest, HeuristicsAutocompleteAttributePhoneTypes) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = base::string16();
   field.name = ASCIIToUTF16("field1");
   field.autocomplete_attribute = "tel-local";
   form.fields.push_back(field);
 
@@ skipping 22 matching lines @@
             form_structure->field(1)->phone_part());
   EXPECT_EQ(HTML_TYPE_TEL_LOCAL_SUFFIX, form_structure->field(2)->html_type());
   EXPECT_EQ(AutofillField::PHONE_SUFFIX,
             form_structure->field(2)->phone_part());
 }
 
 // The heuristics and server predictions should run if there are more than two
 // fillable fields.
 TEST_F(FormStructureTest,
        HeuristicsAndServerPredictions_BigForm_NoAutocompleteAttribute) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Last Name");
@@ skipping 14 matching lines @@
 
   EXPECT_EQ(NAME_FIRST, form_structure->field(0)->heuristic_type());
   EXPECT_EQ(NAME_LAST, form_structure->field(1)->heuristic_type());
   EXPECT_EQ(EMAIL_ADDRESS, form_structure->field(2)->heuristic_type());
 }
 
 // The heuristics and server predictions should run even if a valid autocomplete
 // attribute is present in the form (if it has more that two fillable fields).
 TEST_F(FormStructureTest,
        HeuristicsAndServerPredictions_ValidAutocompleteAttribute) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   // Set a valid autocomplete attribute to the first field.
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
   field.autocomplete_attribute = "given-name";
   form.fields.push_back(field);
@@ skipping 18 matching lines @@
   EXPECT_EQ(NAME_FIRST, form_structure->field(0)->heuristic_type());
   EXPECT_EQ(NAME_LAST, form_structure->field(1)->heuristic_type());
   EXPECT_EQ(EMAIL_ADDRESS, form_structure->field(2)->heuristic_type());
 }
 
 // The heuristics and server predictions should run even if an unrecognized
 // autocomplete attribute is present in the form (if it has more than two
 // fillable fields).
 TEST_F(FormStructureTest,
        HeuristicsAndServerPredictions_UnrecognizedAutocompleteAttribute) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   // Set an unrecognized autocomplete attribute to the first field.
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
   field.autocomplete_attribute = "unrecognized";
   form.fields.push_back(field);
@@ skipping 22 matching lines @@
   EXPECT_EQ(NAME_FIRST, form_structure->field(0)->heuristic_type());
   EXPECT_EQ(NAME_MIDDLE, form_structure->field(1)->heuristic_type());
   EXPECT_EQ(NAME_LAST, form_structure->field(2)->heuristic_type());
   EXPECT_EQ(EMAIL_ADDRESS, form_structure->field(3)->heuristic_type());
 }
 
 // Tests the heuristics and server predictions are not run for forms with less
 // than 3 fields.
 TEST_F(FormStructureTest,
        HeuristicsAndServerPredictions_SmallForm_NoAutocompleteAttribute) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Last Name");
@@ skipping 11 matching lines @@
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(0)->heuristic_type());
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(1)->heuristic_type());
   EXPECT_EQ(NO_SERVER_DATA, form_structure->field(0)->server_type());
   EXPECT_EQ(NO_SERVER_DATA, form_structure->field(1)->server_type());
 }
 
 // Tests the heuristics and server predictions are not run for forms with less
 // than 3 fields, even if an autocomplete attribute is specified.
 TEST_F(FormStructureTest,
        HeuristicsAndServerPredictions_SmallForm_ValidAutocompleteAttribute) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   // Set a valid autocompelete attribute to the first field.
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
   field.autocomplete_attribute = "given-name";
   form.fields.push_back(field);
@@ skipping 218 matching lines @@
   // Normally, the two separate address fields would cause us to detect two
   // separate sections; but because there is an author-specified section in this
   // form, we do not apply these usual heuristics.
   EXPECT_EQ(ASCIIToUTF16("one"), form_structure.field(0)->name);
   EXPECT_EQ(ASCIIToUTF16("two"), form_structure.field(3)->name);
   EXPECT_EQ(form_structure.field(0)->section(),
             form_structure.field(3)->section());
 }
 
 TEST_F(FormStructureTest, HeuristicsSample8) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Your First Name:");
   field.name = ASCIIToUTF16("bill.first");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Your Last Name:");
@@ skipping 56 matching lines @@
   // Country.
   EXPECT_EQ(ADDRESS_HOME_COUNTRY, form_structure->field(7)->heuristic_type());
   // Phone.
   EXPECT_EQ(PHONE_HOME_WHOLE_NUMBER,
       form_structure->field(8)->heuristic_type());
   // Submit.
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(9)->heuristic_type());
 }
 
 TEST_F(FormStructureTest, HeuristicsSample6) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("E-mail address");
   field.name = ASCIIToUTF16("email");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Full name");
@@ skipping 41 matching lines @@
   // Zip.
   EXPECT_EQ(ADDRESS_HOME_ZIP, form_structure->field(5)->heuristic_type());
   // Submit.
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(6)->heuristic_type());
 }
 
 // Tests a sequence of FormFields where only labels are supplied to heuristics
 // for matching.  This works because FormFieldData labels are matched in the
 // case that input element ids (or |name| fields) are missing.
 TEST_F(FormStructureTest, HeuristicsLabelsOnly) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = base::string16();
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Last Name");
@@ skipping 44 matching lines @@
   EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(4)->heuristic_type());
   // Address Line 2.
   EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(5)->heuristic_type());
   // Zip.
   EXPECT_EQ(ADDRESS_HOME_ZIP, form_structure->field(6)->heuristic_type());
   // Submit.
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(7)->heuristic_type());
 }
 
 TEST_F(FormStructureTest, HeuristicsCreditCardInfo) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Name on Card");
   field.name = ASCIIToUTF16("name_on_card");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Card Number");
@@ skipping 33 matching lines @@
   EXPECT_EQ(CREDIT_CARD_EXP_4_DIGIT_YEAR,
             form_structure->field(3)->heuristic_type());
   // CVV.
   EXPECT_EQ(CREDIT_CARD_VERIFICATION_CODE,
             form_structure->field(4)->heuristic_type());
   // Submit.
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(5)->heuristic_type());
 }
 
 TEST_F(FormStructureTest, HeuristicsCreditCardInfoWithUnknownCardField) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Name on Card");
   field.name = ASCIIToUTF16("name_on_card");
   form.fields.push_back(field);
 
   // This is not a field we know how to process.  But we should skip over it
@@ skipping 41 matching lines @@
   EXPECT_EQ(CREDIT_CARD_EXP_4_DIGIT_YEAR,
             form_structure->field(4)->heuristic_type());
   // CVV.
   EXPECT_EQ(CREDIT_CARD_VERIFICATION_CODE,
             form_structure->field(5)->heuristic_type());
   // Submit.
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(6)->heuristic_type());
 }
 
 TEST_F(FormStructureTest, ThreeAddressLines) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Address Line1");
   field.name = ASCIIToUTF16("Address");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Address Line2");
@@ skipping 19 matching lines @@
   // Address Line 2.
   EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(1)->heuristic_type());
   // Address Line 3.
   EXPECT_EQ(ADDRESS_HOME_LINE3, form_structure->field(2)->heuristic_type());
   // City.
   EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(3)->heuristic_type());
 }
 
 // Numbered address lines after line two are ignored.
 TEST_F(FormStructureTest, SurplusAddressLinesIgnored) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Address Line1");
   field.name = ASCIIToUTF16("shipping.address.addressLine1");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Address Line2");
@@ skipping 22 matching lines @@
   // Address Line 4 (ignored).
   EXPECT_EQ(UNKNOWN_TYPE, form_structure->field(3)->heuristic_type());
 }
 
 // This example comes from expedia.com where they used to use a "Suite" label
 // to indicate a suite or apartment number (the form has changed since this
 // test was written). We interpret this as address line 2. And the following
 // "Street address second line" we interpret as address line 3.
 // See http://crbug.com/48197 for details.
 TEST_F(FormStructureTest, ThreeAddressLinesExpedia) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Street:");
   field.name = ASCIIToUTF16("FOPIH_RgWebCC_0_IHAddress_ads1");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Suite or Apt:");
@@ skipping 21 matching lines @@
   // Address Line 3.
   EXPECT_EQ(ADDRESS_HOME_LINE3, form_structure->field(2)->heuristic_type());
   // City.
   EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(3)->heuristic_type());
 }
 
 // This example comes from ebay.com where the word "suite" appears in the label
 // and the name "address2" clearly indicates that this is the address line 2.
 // See http://crbug.com/48197 for details.
 TEST_F(FormStructureTest, TwoAddressLinesEbay) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Address Line1");
   field.name = ASCIIToUTF16("address1");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Floor number, suite number, etc");
@@ skipping 12 matching lines @@
 
   // Address Line 1.
   EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(0)->heuristic_type());
   // Address Line 2.
   EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(1)->heuristic_type());
   // City.
   EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(2)->heuristic_type());
 }
 
 TEST_F(FormStructureTest, HeuristicsStateWithProvince) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Address Line1");
   field.name = ASCIIToUTF16("Address");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Address Line2");
@@ skipping 13 matching lines @@
   // Address Line 1.
   EXPECT_EQ(ADDRESS_HOME_LINE1, form_structure->field(0)->heuristic_type());
   // Address Line 2.
   EXPECT_EQ(ADDRESS_HOME_LINE2, form_structure->field(1)->heuristic_type());
   // State.
   EXPECT_EQ(ADDRESS_HOME_STATE, form_structure->field(2)->heuristic_type());
 }
 
 // This example comes from lego.com's checkout page.
 TEST_F(FormStructureTest, HeuristicsWithBilling) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name*:");
   field.name = ASCIIToUTF16("editBillingAddress$firstNameBox");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Last Name*:");
@@ skipping 50 matching lines @@
   EXPECT_EQ(ADDRESS_HOME_CITY, form_structure->field(5)->heuristic_type());
   EXPECT_EQ(ADDRESS_HOME_STATE, form_structure->field(6)->heuristic_type());
   EXPECT_EQ(ADDRESS_HOME_COUNTRY, form_structure->field(7)->heuristic_type());
   EXPECT_EQ(ADDRESS_HOME_ZIP, form_structure->field(8)->heuristic_type());
   EXPECT_EQ(PHONE_HOME_WHOLE_NUMBER,
             form_structure->field(9)->heuristic_type());
   EXPECT_EQ(EMAIL_ADDRESS, form_structure->field(10)->heuristic_type());
 }
 
 TEST_F(FormStructureTest, ThreePartPhoneNumber) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Phone:");
   field.name = ASCIIToUTF16("dayphone1");
   field.max_length = 0;
   form.fields.push_back(field);
 
@@ skipping 26 matching lines @@
   EXPECT_EQ(PHONE_HOME_NUMBER,
             form_structure->field(1)->heuristic_type());
   // Phone number suffix.
   EXPECT_EQ(PHONE_HOME_NUMBER,
             form_structure->field(2)->heuristic_type());
   // Phone extension.
   EXPECT_EQ(PHONE_HOME_EXTENSION, form_structure->field(3)->heuristic_type());
 }
 
 TEST_F(FormStructureTest, HeuristicsInfernoCC) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Name on Card");
   field.name = ASCIIToUTF16("name_on_card");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Address");
@@ skipping 29 matching lines @@
   // Expiration Date.
   EXPECT_EQ(CREDIT_CARD_EXP_MONTH, form_structure->field(3)->heuristic_type());
   // Expiration Year.
   EXPECT_EQ(CREDIT_CARD_EXP_4_DIGIT_YEAR,
             form_structure->field(4)->heuristic_type());
 }
 
 // Tests that the heuristics detect split credit card names if they appear in
 // the middle of the form.
 TEST_F(FormStructureTest, HeuristicsInferCCNames_NamesNotFirst) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Card number");
   field.name = ASCIIToUTF16("ccnumber");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("First name");
@@ skipping 37 matching lines @@
             form_structure->field(4)->heuristic_type());
   // CVC code.
   EXPECT_EQ(CREDIT_CARD_VERIFICATION_CODE,
             form_structure->field(5)->heuristic_type());
 }
 
 // Tests that the heuristics detect split credit card names if they appear at
 // the beginning of the form. The first name has to contains some credit card
 // keyword.
 TEST_F(FormStructureTest, HeuristicsInferCCNames_NamesFirst) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("Cardholder Name");
   field.name = ASCIIToUTF16("cc_first_name");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("Last name");
@@ skipping 185 matching lines @@
 
   // Check that we fail if there are only bad form(s).
   ScopedVector<FormStructure> bad_forms;
   bad_forms.push_back(new FormStructure(malformed_form));
   AutofillQueryContents encoded_query5;
   EXPECT_FALSE(FormStructure::EncodeQueryRequest(
       bad_forms.get(), &encoded_signatures, &encoded_query5));
 }
 
 TEST_F(FormStructureTest, EncodeUploadRequest) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
@@ skipping 155 matching lines @@
   for (size_t i = 0; i < form_structure->field_count(); ++i)
     form_structure->field(i)->set_possible_types(possible_field_types[i]);
 
   AutofillUploadContents encoded_upload4;
   EXPECT_FALSE(form_structure->EncodeUploadRequest(
       available_field_types, false, std::string(), true, &encoded_upload4));
 }
 
 TEST_F(FormStructureTest,
        EncodeUploadRequestWithAdditionalPasswordFormSignature) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
 
   FormFieldData field;
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
   field.autocomplete_attribute = "given-name";
   form.fields.push_back(field);
@@ skipping 78 matching lines @@
   AutofillUploadContents encoded_upload;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(available_field_types, true,
                                                   "42", true, &encoded_upload));
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
   EXPECT_EQ(expected_upload_string, encoded_upload_string);
 }
 
 TEST_F(FormStructureTest, EncodeUploadRequest_WithAutocomplete) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
@@ skipping 50 matching lines @@
   AutofillUploadContents encoded_upload;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, true, std::string(), true, &encoded_upload));
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
   EXPECT_EQ(expected_upload_string, encoded_upload_string);
 }
 
 TEST_F(FormStructureTest, EncodeUploadRequest_ObservedSubmissionFalse) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
@@ skipping 48 matching lines @@
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, true, std::string(),
       /* observed_submission= */ false, &encoded_upload));
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
   EXPECT_EQ(expected_upload_string, encoded_upload_string);
 }
 
 TEST_F(FormStructureTest, EncodeUploadRequest_WithLabels) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
 
   FormFieldData field;
   field.form_control_type = "text";
 
   // No label for the first field.
   form.fields.push_back(field);
@@ skipping 44 matching lines @@
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, true, std::string(), true, &encoded_upload));
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
   EXPECT_EQ(expected_upload_string, encoded_upload_string);
 }
 
 // Test that the form name is sent in the upload request.
 TEST_F(FormStructureTest, EncodeUploadRequest_WithFormName) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
   // Setting the form name which we expect to see in the upload.
   form.name = ASCIIToUTF16("myform");
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
 
   FormFieldData field;
   field.form_control_type = "text";
 
@@ skipping 43 matching lines @@
   AutofillUploadContents encoded_upload;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, true, std::string(), true, &encoded_upload));
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
   EXPECT_EQ(expected_upload_string, encoded_upload_string);
 }
 
 TEST_F(FormStructureTest, EncodeUploadRequestPartialMetadata) {
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
 
   FormFieldData field;
   field.form_control_type = "text";
 
   // Some fields don't have "name" or "autocomplete" attributes, and some have
   // neither.
@@ skipping 52 matching lines @@
 
   std::string encoded_upload_string;
   encoded_upload.SerializeToString(&encoded_upload_string);
   EXPECT_EQ(expected_upload_string, encoded_upload_string);
 }
 
 // Sending field metadata to the server is disabled.
 TEST_F(FormStructureTest, EncodeUploadRequest_DisabledMetadataTrial) {
   DisableAutofillMetadataFieldTrial();
 
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
   form_structure.reset(new FormStructure(form));
   form_structure->DetermineHeuristicTypes();
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("First Name");
   field.name = ASCIIToUTF16("firstname");
@@ skipping 312 matching lines @@
   available_field_types.insert(NAME_FIRST);
   available_field_types.insert(NAME_LAST);
   available_field_types.insert(EMAIL_ADDRESS);
   available_field_types.insert(ADDRESS_HOME_LINE1);
   available_field_types.insert(ADDRESS_HOME_LINE2);
   available_field_types.insert(ADDRESS_HOME_CITY);
   available_field_types.insert(ADDRESS_HOME_STATE);
   available_field_types.insert(COMPANY_NAME);
 
   // Check that multiple types for the field are processed correctly.
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   std::vector<ServerFieldTypeSet> possible_field_types;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("email");
   field.name = ASCIIToUTF16("email");
   form.fields.push_back(field);
   possible_field_types.push_back(ServerFieldTypeSet());
@@ skipping 105 matching lines @@
   AutofillUploadContents encoded_upload4;
   EXPECT_TRUE(form_structure->EncodeUploadRequest(
       available_field_types, false, std::string(), true, &encoded_upload4));
 
   encoded_upload4.SerializeToString(&encoded_upload_string);
   EXPECT_EQ(expected_upload_string, encoded_upload_string);
 }
 
 TEST_F(FormStructureTest, CheckFormSignature) {
   // Check that form signature is created correctly.
-  scoped_ptr<FormStructure> form_structure;
+  std::unique_ptr<FormStructure> form_structure;
   FormData form;
 
   FormFieldData field;
   field.form_control_type = "text";
 
   field.label = ASCIIToUTF16("email");
   field.name = ASCIIToUTF16("email");
   form.fields.push_back(field);
 
   field.label = ASCIIToUTF16("First Name");
@@ skipping 509 matching lines @@
   prefix = FormStructure::FindLongestCommonPrefix(strings);
   EXPECT_EQ(ASCIIToUTF16("1234567890123456"), prefix);
 
   // Empty vector.
   strings.clear();
   prefix = FormStructure::FindLongestCommonPrefix(strings);
   EXPECT_EQ(ASCIIToUTF16(""), prefix);
 }
 
 }  // namespace autofill