Rename card 'type' into 'issuer network.'

components/autofill/core/browser/autofill_manager_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/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 63 matching lines @@
 using testing::AtLeast;
 using testing::Return;
 using testing::SaveArg;
 
 namespace autofill {
 
 namespace {
 
 const int kDefaultPageID = 137;
 
-const std::string kUTF8MidlineEllipsis =
+const char kUTF8MidlineEllipsis[] =
     "  "
     "\xE2\x80\xA2\xE2\x80\x86"
     "\xE2\x80\xA2\xE2\x80\x86"
     "\xE2\x80\xA2\xE2\x80\x86"
     "\xE2\x80\xA2\xE2\x80\x86";
 
 class MockAutofillClient : public TestAutofillClient {
  public:
   MockAutofillClient() {}
 
@@ skipping 118 matching lines @@
     AutofillProfile* profile = GetProfileWithGUID(guid.c_str());
     if (profile) {
       web_profiles_.erase(
           std::find_if(web_profiles_.begin(), web_profiles_.end(),
                        [profile](const std::unique_ptr<AutofillProfile>& ptr) {
                          return ptr.get() == profile;
                        }));
     }
   }
 
-  void ClearAutofillProfiles() {
-    web_profiles_.clear();
-  }
+  void ClearAutofillProfiles() { web_profiles_.clear(); }
 
   void ClearCreditCards() {
     local_credit_cards_.clear();
     server_credit_cards_.clear();
   }
 
   // Create Elvis card with whitespace in the credit card number.
   void CreateTestCreditCardWithWhitespace() {
     ClearCreditCards();
     std::unique_ptr<CreditCard> credit_card = base::MakeUnique<CreditCard>();
@@ skipping 184 matching lines @@
     ExpectFilledField("First Name", "firstname", first, "text",
                       filled_form.fields[0]);
     ExpectFilledField("Middle Name", "middlename", middle, "text",
                       filled_form.fields[1]);
     ExpectFilledField("Last Name", "lastname", last, "text",
                       filled_form.fields[2]);
     ExpectFilledField("Address Line 1", "addr1", address1, "text",
                       filled_form.fields[3]);
     ExpectFilledField("Address Line 2", "addr2", address2, "text",
                       filled_form.fields[4]);
-    ExpectFilledField("City", "city", city, "text",
-                      filled_form.fields[5]);
-    ExpectFilledField("State", "state", state, "text",
-                      filled_form.fields[6]);
+    ExpectFilledField("City", "city", city, "text", filled_form.fields[5]);
+    ExpectFilledField("State", "state", state, "text", filled_form.fields[6]);
     ExpectFilledField("Postal Code", "zipcode", postal_code, "text",
                       filled_form.fields[7]);
     ExpectFilledField("Country", "country", country, "text",
                       filled_form.fields[8]);
     ExpectFilledField("Phone Number", "phonenumber", phone, "tel",
                       filled_form.fields[9]);
-    ExpectFilledField("Email", "email", email, "email",
-                      filled_form.fields[10]);
+    ExpectFilledField("Email", "email", email, "email", filled_form.fields[10]);
   }
 
   if (has_credit_card_fields) {
-    size_t offset = has_address_fields? kAddressFormSize : 0;
+    size_t offset = has_address_fields ? kAddressFormSize : 0;
     ExpectFilledField("Name on Card", "nameoncard", name_on_card, "text",
                       filled_form.fields[offset + 0]);
     ExpectFilledField("Card Number", "cardnumber", card_number, "text",
                       filled_form.fields[offset + 1]);
     if (use_month_type) {
       std::string exp_year = expiration_year;
       std::string exp_month = expiration_month;
       std::string date;
       if (!exp_year.empty() && !exp_month.empty())
         date = exp_year + "-" + exp_month;
@@ skipping 38 matching lines @@
   ExpectFilledForm(page_id, filled_form, expected_page_id, "", "", "", "", "",
                    "", "", "", "", "", "", "Miku Hatsune", "4234567890654321",
                    month, year, has_address_fields, true, true);
 }
 
 class MockAutocompleteHistoryManager : public AutocompleteHistoryManager {
  public:
   MockAutocompleteHistoryManager(AutofillDriver* driver, AutofillClient* client)
       : AutocompleteHistoryManager(driver, client) {}
 
-  MOCK_METHOD4(OnGetAutocompleteSuggestions, void(
-      int query_id,
-      const base::string16& name,
-      const base::string16& prefix,
-      const std::string& form_control_type));
+  MOCK_METHOD4(OnGetAutocompleteSuggestions,
+               void(int query_id,
+                    const base::string16& name,
+                    const base::string16& prefix,
+                    const std::string& form_control_type));
   MOCK_METHOD1(OnWillSubmitForm, void(const FormData& form));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAutocompleteHistoryManager);
 };
 
 class MockAutofillDriver : public TestAutofillDriver {
  public:
   MockAutofillDriver()
       : is_incognito_(false), did_interact_with_credit_card_form_(false) {}
 
   // Mock methods to enable testability.
-  MOCK_METHOD3(SendFormDataToRenderer, void(int query_id,
-                                            RendererFormDataAction action,
-                                            const FormData& data));
+  MOCK_METHOD3(SendFormDataToRenderer,
+               void(int query_id,
+                    RendererFormDataAction action,
+                    const FormData& data));
 
-  void SetIsIncognito(bool is_incognito) {
-    is_incognito_ = is_incognito;
-  }
+  void SetIsIncognito(bool is_incognito) { is_incognito_ = is_incognito; }
 
   bool IsIncognito() const override { return is_incognito_; }
 
   void DidInteractWithCreditCardForm() override {
     did_interact_with_credit_card_form_ = true;
-  };
+  }
 
   void ClearDidInteractWithCreditCardForm() {
     did_interact_with_credit_card_form_ = false;
-  };
+  }
 
   bool did_interact_with_credit_card_form() const {
     return did_interact_with_credit_card_form_;
   }
 
  private:
   bool is_incognito_;
   bool did_interact_with_credit_card_form_;
   DISALLOW_COPY_AND_ASSIGN(MockAutofillDriver);
 };
@@ skipping 51 matching lines @@
                                    bool observed_submission) override {
     run_loop_->Quit();
 
     EXPECT_EQ(expected_observed_submission_, observed_submission);
 
     // If we have expected field types set, make sure they match.
     if (!expected_submitted_field_types_.empty()) {
       ASSERT_EQ(expected_submitted_field_types_.size(),
                 submitted_form->field_count());
       for (size_t i = 0; i < expected_submitted_field_types_.size(); ++i) {
-        SCOPED_TRACE(
-            base::StringPrintf(
-                "Field %d with value %s", static_cast<int>(i),
-                base::UTF16ToUTF8(submitted_form->field(i)->value).c_str()));
+        SCOPED_TRACE(base::StringPrintf(
+            "Field %d with value %s", static_cast<int>(i),
+            base::UTF16ToUTF8(submitted_form->field(i)->value).c_str()));
         const ServerFieldTypeSet& possible_types =
             submitted_form->field(i)->possible_types();
         EXPECT_EQ(expected_submitted_field_types_[i].size(),
                   possible_types.size());
         for (ServerFieldTypeSet::const_iterator it =
                  expected_submitted_field_types_[i].begin();
              it != expected_submitted_field_types_[i].end(); ++it) {
           EXPECT_TRUE(possible_types.count(*it))
               << "Expected type: " << AutofillType(*it).ToString();
         }
@@ skipping 52 matching lines @@
     std::string credit_card_guid =
         base::StringPrintf("00000000-0000-0000-0000-%012d", credit_card_id);
 
     return MakeFrontendID(credit_card_guid, std::string());
   }
 
   void AddSeenForm(std::unique_ptr<FormStructure> form) {
     form_structures()->push_back(std::move(form));
   }
 
-  void ClearFormStructures() {
-    form_structures()->clear();
-  }
+  void ClearFormStructures() { form_structures()->clear(); }
 
   void ResetPaymentsClientForCardUpload(const char* server_id) {
     TestPaymentsClient* payments_client =
         new TestPaymentsClient(context_getter_, this);
     payments_client->server_id_ = server_id;
     set_payments_client(payments_client);
   }
 
  private:
   void OnDidUploadCard(AutofillClient::PaymentsRpcResult result,
@@ skipping 160 matching lines @@
     request_context_ = new net::TestURLRequestContextGetter(
         base::ThreadTaskRunnerHandle::Get());
     autofill_driver_->SetURLRequestContext(request_context_.get());
     autofill_manager_.reset(new TestAutofillManager(
         autofill_driver_.get(), &autofill_client_, &personal_data_));
     download_manager_ = new TestAutofillDownloadManager(
         autofill_driver_.get(), autofill_manager_.get());
     // AutofillManager takes ownership of |download_manager_|.
     autofill_manager_->set_download_manager(download_manager_);
     external_delegate_.reset(new TestAutofillExternalDelegate(
-        autofill_manager_.get(),
-        autofill_driver_.get()));
+        autofill_manager_.get(), autofill_driver_.get()));
     autofill_manager_->SetExternalDelegate(external_delegate_.get());
 
     // Clear all the things.
     variations::testing::ClearAllVariationParams();
   }
 
   void TearDown() override {
     // Order of destruction is important as AutofillManager relies on
     // PersonalDataManager to be around when it gets destroyed.
     autofill_manager_.reset();
@@ skipping 35 matching lines @@
         (!personal_data_.GetProfiles().empty() ||
          !personal_data_.GetCreditCards().empty()))
       autofill_manager_->WaitForAsyncUploadProcess();
     autofill_manager_->OnFormSubmitted(form);
   }
 
   void FillAutofillFormData(int query_id,
                             const FormData& form,
                             const FormFieldData& field,
                             int unique_id) {
-    autofill_manager_->FillOrPreviewForm(
-        AutofillDriver::FORM_DATA_ACTION_FILL, query_id, form, field,
-        unique_id);
+    autofill_manager_->FillOrPreviewForm(AutofillDriver::FORM_DATA_ACTION_FILL,
+                                         query_id, form, field, unique_id);
   }
 
   // Calls |autofill_manager_->OnFillAutofillFormData()| with the specified
   // input parameters after setting up the expectation that the mock driver's
   // |SendFormDataToRenderer()| method will be called and saving the parameters
   // of that call into the |response_query_id| and |response_data| output
   // parameters.
   void FillAutofillFormDataAndSaveResults(int input_query_id,
                                           const FormData& input_form,
                                           const FormFieldData& input_field,
                                           int unique_id,
                                           int* response_query_id,
                                           FormData* response_data) {
-    EXPECT_CALL(*autofill_driver_, SendFormDataToRenderer(_, _, _)).
-        WillOnce((DoAll(testing::SaveArg<0>(response_query_id),
-                        testing::SaveArg<2>(response_data))));
+    EXPECT_CALL(*autofill_driver_, SendFormDataToRenderer(_, _, _))
+        .WillOnce((DoAll(testing::SaveArg<0>(response_query_id),
+                         testing::SaveArg<2>(response_data))));
     FillAutofillFormData(input_query_id, input_form, input_field, unique_id);
   }
 
   int MakeFrontendID(const std::string& cc_sid,
                      const std::string& profile_sid) const {
     return autofill_manager_->MakeFrontendID(cc_sid, profile_sid);
   }
 
   bool WillFillCreditCardNumber(const FormData& form,
                                 const FormFieldData& field) {
@@ skipping 14 matching lines @@
       form->origin = GURL("http://myform.com/form.html");
       form->action = GURL("http://myform.com/submit.html");
     }
 
     FormFieldData field;
     test::CreateTestFormField("Name on Card", "nameoncard", "", "text", &field);
     form->fields.push_back(field);
     test::CreateTestFormField("Card Number", "cardnumber", "", "text", &field);
     form->fields.push_back(field);
     if (use_month_type) {
-      test::CreateTestFormField(
-          "Expiration Date", "ccmonth", "", "month", &field);
+      test::CreateTestFormField("Expiration Date", "ccmonth", "", "month",
+                                &field);
       form->fields.push_back(field);
     } else {
       test::CreateTestFormField("Expiration Date", "ccmonth", "", "text",
                                 &field);
       form->fields.push_back(field);
       test::CreateTestFormField("", "ccyear", "", "text", &field);
       form->fields.push_back(field);
     }
     test::CreateTestFormField("CVC", "cvc", "", "text", &field);
     form->fields.push_back(field);
@@ skipping 43 matching lines @@
     // This line silences the warning from PaymentsClient about matching sync
     // and Payments server types.
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         "sync-url", "https://google.com");
 
     CreateTestCreditCardFormData(form, true, false);
     FormsSeen(std::vector<FormData>(1, *form));
     *card = CreditCard(CreditCard::MASKED_SERVER_CARD, "a123");
     test::SetCreditCardInfo(card, "John Dillinger", "1881" /* Visa */, "01",
                             "2017");
-    card->SetTypeForMaskedCard(kVisaCard);
+    card->SetNetworkForMaskedCard(kVisaCard);
 
     EXPECT_CALL(*autofill_driver_, SendFormDataToRenderer(_, _, _))
         .Times(AtLeast(1));
     autofill_manager_->FillOrPreviewCreditCardForm(
         AutofillDriver::FORM_DATA_ACTION_FILL, kDefaultPageID, *form,
         form->fields[0], *card);
   }
 
   // Convenience method for using and retrieving a mock autocomplete history
   // manager.
   MockAutocompleteHistoryManager* RecreateMockAutocompleteHistoryManager() {
-    MockAutocompleteHistoryManager* manager = new
-        MockAutocompleteHistoryManager(autofill_driver_.get(),
-                                       autofill_manager_->client());
+    MockAutocompleteHistoryManager* manager =
+        new MockAutocompleteHistoryManager(autofill_driver_.get(),
+                                           autofill_manager_->client());
     autofill_manager_->autocomplete_history_manager_.reset(manager);
     return manager;
   }
 
   // Convenience method to cast the FullCardRequest into a CardUnmaskDelegate.
   CardUnmaskDelegate* full_card_unmask_delegate() {
     DCHECK(autofill_manager_->full_card_request_);
     return static_cast<CardUnmaskDelegate*>(
         autofill_manager_->full_card_request_.get());
   }
@@ skipping 95 matching lines @@
   std::unique_ptr<TestAutofillExternalDelegate> external_delegate_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
   TestAutofillDownloadManager* download_manager_;
   TestPersonalDataManager personal_data_;
   base::FieldTrialList field_trial_list_;
   base::test::ScopedFeatureList scoped_feature_list_;
 };
 
 class TestFormStructure : public FormStructure {
  public:
-  explicit TestFormStructure(const FormData& form)
-      : FormStructure(form) {}
+  explicit TestFormStructure(const FormData& form) : FormStructure(form) {}
   ~TestFormStructure() override {}
 
   void SetFieldTypes(const std::vector<ServerFieldType>& heuristic_types,
                      const std::vector<ServerFieldType>& server_types) {
     ASSERT_EQ(field_count(), heuristic_types.size());
     ASSERT_EQ(field_count(), server_types.size());
 
     for (size_t i = 0; i < field_count(); ++i) {
       AutofillField* form_field = field(i);
       ASSERT_TRUE(form_field);
@@ skipping 12 matching lines @@
 // reloading a page or when the renderer processes a set of forms but detects
 // no changes) does not load the forms again.
 TEST_F(AutofillManagerTest, OnFormsSeen_Empty) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
 
   base::HistogramTester histogram_tester;
   FormsSeen(forms);
-  histogram_tester.ExpectUniqueSample(
-      "Autofill.UserHappiness", 0 /* FORMS_LOADED */, 1);
+  histogram_tester.ExpectUniqueSample("Autofill.UserHappiness",
+                                      0 /* FORMS_LOADED */, 1);
 
   // No more forms, metric is not logged.
   forms.clear();
   FormsSeen(forms);
-  histogram_tester.ExpectUniqueSample(
-      "Autofill.UserHappiness", 0 /* FORMS_LOADED */, 1);
+  histogram_tester.ExpectUniqueSample("Autofill.UserHappiness",
+                                      0 /* FORMS_LOADED */, 1);
 }
 
 // Test that calling OnFormsSeen consecutively with a different set of forms
 // will query for each separately.
 TEST_F(AutofillManagerTest, OnFormsSeen_DifferentFormStructures) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
 
@@ skipping 202 matching lines @@
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field;
   test::CreateTestFormField("First Name", "firstname", "E", "text", &field);
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate.
   external_delegate_->CheckSuggestions(
-      kDefaultPageID,
-      Suggestion("Elvis", "3734 Elvis Presley Blvd.", "", 1));
+      kDefaultPageID, Suggestion("Elvis", "3734 Elvis Presley Blvd.", "", 1));
 }
 
 // Tests that we return address profile suggestions values when the section
 // is already autofilled, and that we merge identical values.
 TEST_F(AutofillManagerTest,
        GetProfileSuggestions_AlreadyAutofilledMergeValues) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
@@ skipping 55 matching lines @@
   // First name is already autofilled which will make the section appear as
   // "already autofilled".
   form.fields[0].is_autofilled = true;
 
   FormFieldData field;
   test::CreateTestFormField("First Name", "firstname", "E", "text", &field);
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate. No labels.
   external_delegate_->CheckSuggestions(
-      kDefaultPageID,
-      Suggestion("Elvis", "" /* no label */, "", 1));
+      kDefaultPageID, Suggestion("Elvis", "" /* no label */, "", 1));
 }
 
 // Test that we return no suggestions when the form has no relevant fields.
 TEST_F(AutofillManagerTest, GetProfileSuggestions_UnknownFields) {
   // Set up our form data.
   FormData form;
   form.name = ASCIIToUTF16("MyForm");
   form.origin = GURL("http://myform.com/form.html");
   form.action = GURL("http://myform.com/submit.html");
 
@@ skipping 60 matching lines @@
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[1];
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate.
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, Suggestion("Visa" + kUTF8MidlineEllipsis + "3456",
-                                 "04/99", kVisaCard,
-                                 autofill_manager_->GetPackedCreditCardID(4)),
-      Suggestion("MasterCard" + kUTF8MidlineEllipsis + "8765", "10/98",
-                 kMasterCard, autofill_manager_->GetPackedCreditCardID(5)));
+      kDefaultPageID,
+      Suggestion(std::string("Visa") + kUTF8MidlineEllipsis + "3456", "04/99",
+                 kVisaCard, autofill_manager_->GetPackedCreditCardID(4)),
+      Suggestion(std::string("MasterCard") + kUTF8MidlineEllipsis + "8765",
+                 "10/98", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(5)));
 }
 
 // Test that we return all credit card profile suggestions when the triggering
 // field has whitespace in it.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestions_Whitespace) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[1];
   field.value = ASCIIToUTF16("       ");
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate.
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, Suggestion("Visa" + kUTF8MidlineEllipsis + "3456",
-                                 "04/99", kVisaCard,
-                                 autofill_manager_->GetPackedCreditCardID(4)),
-      Suggestion("MasterCard" + kUTF8MidlineEllipsis + "8765", "10/98",
-                 kMasterCard, autofill_manager_->GetPackedCreditCardID(5)));
+      kDefaultPageID,
+      Suggestion(std::string("Visa") + kUTF8MidlineEllipsis + "3456", "04/99",
+                 kVisaCard, autofill_manager_->GetPackedCreditCardID(4)),
+      Suggestion(std::string("MasterCard") + kUTF8MidlineEllipsis + "8765",
+                 "10/98", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(5)));
 }
 
 // Test that we return all credit card profile suggestions when the triggering
 // field has stop characters in it, which should be removed.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestions_StopCharsOnly) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[1];
   field.value = ASCIIToUTF16("____-____-____-____");
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate.
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, Suggestion("Visa" + kUTF8MidlineEllipsis + "3456",
-                                 "04/99", kVisaCard,
-                                 autofill_manager_->GetPackedCreditCardID(4)),
-      Suggestion("MasterCard" + kUTF8MidlineEllipsis + "8765", "10/98",
-                 kMasterCard, autofill_manager_->GetPackedCreditCardID(5)));
+      kDefaultPageID,
+      Suggestion(std::string("Visa") + kUTF8MidlineEllipsis + "3456", "04/99",
+                 kVisaCard, autofill_manager_->GetPackedCreditCardID(4)),
+      Suggestion(std::string("MasterCard") + kUTF8MidlineEllipsis + "8765",
+                 "10/98", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(5)));
 }
 
 // Test that we return all credit card profile suggestions when the triggering
 // field has stop characters in it and some input.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestions_StopCharsWithInput) {
   // Add a credit card with particular numbers that we will attempt to recall.
   CreditCard credit_card;
   test::SetCreditCardInfo(&credit_card, "John Smith",
                           "5255667890123123",  // Mastercard
                           "08", "2017");
   credit_card.set_guid("00000000-0000-0000-0000-000000000007");
   autofill_manager_->AddCreditCard(credit_card);
 
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[1];
 
   field.value = ASCIIToUTF16("5255-66__-____-____");
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right value to the external delegate.
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, Suggestion("MasterCard" + kUTF8MidlineEllipsis + "3123",
-                                 "08/17", kMasterCard,
-                                 autofill_manager_->GetPackedCreditCardID(7)));
+      kDefaultPageID,
+      Suggestion(std::string("MasterCard") + kUTF8MidlineEllipsis + "3123",
+                 "08/17", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(7)));
 }
 
 // Test that we return only matching credit card profile suggestions when the
 // selected form field has been partially filled out.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestions_MatchCharacter) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field;
   test::CreateTestFormField("Card Number", "cardnumber", "78", "text", &field);
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate.
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, Suggestion("Visa" + kUTF8MidlineEllipsis + "3456",
-                                 "04/99", kVisaCard,
-                                 autofill_manager_->GetPackedCreditCardID(4)));
+      kDefaultPageID,
+      Suggestion(std::string("Visa") + kUTF8MidlineEllipsis + "3456", "04/99",
+                 kVisaCard, autofill_manager_->GetPackedCreditCardID(4)));
 }
 
 // Test that we return credit card profile suggestions when the selected form
 // field is not the credit card number field.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestions_NonCCNumber) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
 #if defined(OS_ANDROID)
   static const std::string kVisaSuggestion =
-      "Visa" + kUTF8MidlineEllipsis + "3456";
+      std::string("Visa") + kUTF8MidlineEllipsis + "3456";
   static const std::string kMcSuggestion =
-      "MasterCard" + kUTF8MidlineEllipsis + "8765";
+      std::string("MasterCard") + kUTF8MidlineEllipsis + "8765";
 #else
   static const std::string kVisaSuggestion = "*3456";
   static const std::string kMcSuggestion = "*8765";
 #endif
 
   // Test that we sent the right values to the external delegate.
   external_delegate_->CheckSuggestions(
       kDefaultPageID,
       Suggestion("Elvis Presley", kVisaSuggestion, kVisaCard,
                  autofill_manager_->GetPackedCreditCardID(4)),
       Suggestion("Buddy Holly", kMcSuggestion, kMasterCard,
                  autofill_manager_->GetPackedCreditCardID(5)));
 }
 
 // Test that we return a warning explaining that credit card profile suggestions
 // are unavailable when the page and the form target URL are not secure.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestions_NonSecureContext) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, /* is_https */ false, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   const FormFieldData& field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate.
   external_delegate_->CheckSuggestions(
-      kDefaultPageID,
-      Suggestion(
-          l10n_util::GetStringUTF8(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION),
-          "", "", -1));
+      kDefaultPageID, Suggestion(l10n_util::GetStringUTF8(
+                                     IDS_AUTOFILL_WARNING_INSECURE_CONNECTION),
+                                 "", "", -1));
 
   // Clear the test credit cards and try again -- we shouldn't return a warning.
   personal_data_.ClearCreditCards();
   GetAutofillSuggestions(form, field);
   // Autocomplete suggestions are queried, but not Autofill.
   EXPECT_FALSE(external_delegate_->on_suggestions_returned_seen());
 }
 
 // Test that we return an extra "Payment not secure" warning when the page and
 // the form target URL are not secure.
@@ skipping 47 matching lines @@
   FormData form;
   CreateTestCreditCardFormData(&form, /* is_https */ true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[1];
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate.
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, Suggestion("Visa" + kUTF8MidlineEllipsis + "3456",
-                                 "04/99", kVisaCard,
-                                 autofill_manager_->GetPackedCreditCardID(4)),
-      Suggestion("MasterCard" + kUTF8MidlineEllipsis + "8765", "10/98",
-                 kMasterCard, autofill_manager_->GetPackedCreditCardID(5)));
+      kDefaultPageID,
+      Suggestion(std::string("Visa") + kUTF8MidlineEllipsis + "3456", "04/99",
+                 kVisaCard, autofill_manager_->GetPackedCreditCardID(4)),
+      Suggestion(std::string("MasterCard") + kUTF8MidlineEllipsis + "8765",
+                 "10/98", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(5)));
 }
 
 // Test that we will eventually return the credit card signin promo when there
 // are no credit card suggestions and the promo is active. See the tests in
 // AutofillExternalDelegateTest that test whether the promo is added.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestions_OnlySigninPromo) {
   personal_data_.ClearCreditCards();
 
   // Set up our form data.
   FormData form;
@@ skipping 59 matching lines @@
   // Clear the form action.
   form.action = GURL();
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[1];
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate.
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, Suggestion("Visa" + kUTF8MidlineEllipsis + "3456",
-                                 "04/99", kVisaCard,
-                                 autofill_manager_->GetPackedCreditCardID(4)),
-      Suggestion("MasterCard" + kUTF8MidlineEllipsis + "8765", "10/98",
-                 kMasterCard, autofill_manager_->GetPackedCreditCardID(5)));
+      kDefaultPageID,
+      Suggestion(std::string("Visa") + kUTF8MidlineEllipsis + "3456", "04/99",
+                 kVisaCard, autofill_manager_->GetPackedCreditCardID(4)),
+      Suggestion(std::string("MasterCard") + kUTF8MidlineEllipsis + "8765",
+                 "10/98", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(5)));
 }
 
 // Test that we return credit card suggestions for secure pages that have a
 // form action set to "javascript:something".
 TEST_F(AutofillManagerTest,
        GetCreditCardSuggestions_SecureContext_JavascriptFormAction) {
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   // Have the form action be a javascript function (which is a valid URL).
   form.action = GURL("javascript:alert('Hello');");
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[1];
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate.
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, Suggestion("Visa" + kUTF8MidlineEllipsis + "3456",
-                                 "04/99", kVisaCard,
-                                 autofill_manager_->GetPackedCreditCardID(4)),
-      Suggestion("MasterCard" + kUTF8MidlineEllipsis + "8765", "10/98",
-                 kMasterCard, autofill_manager_->GetPackedCreditCardID(5)));
+      kDefaultPageID,
+      Suggestion(std::string("Visa") + kUTF8MidlineEllipsis + "3456", "04/99",
+                 kVisaCard, autofill_manager_->GetPackedCreditCardID(4)),
+      Suggestion(std::string("MasterCard") + kUTF8MidlineEllipsis + "8765",
+                 "10/98", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(5)));
 }
 
 // Test that we return all credit card suggestions in the case that two cards
 // have the same obfuscated number.
 TEST_F(AutofillManagerTest, GetCreditCardSuggestions_RepeatedObfuscatedNumber) {
   // Add a credit card with the same obfuscated number as Elvis's.
   // |credit_card| will be owned by the mock PersonalDataManager.
   CreditCard credit_card;
   test::SetCreditCardInfo(&credit_card, "Elvis Presley",
                           "5231567890123456",  // Mastercard
                           "05", "2999");
   credit_card.set_guid("00000000-0000-0000-0000-000000000007");
   credit_card.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(15));
   autofill_manager_->AddCreditCard(credit_card);
 
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[1];
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate.
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, Suggestion("Visa" + kUTF8MidlineEllipsis + "3456",
-                                 "04/99", kVisaCard,
-                                 autofill_manager_->GetPackedCreditCardID(4)),
-      Suggestion("MasterCard" + kUTF8MidlineEllipsis + "8765", "10/98",
-                 kMasterCard, autofill_manager_->GetPackedCreditCardID(5)),
-      Suggestion("MasterCard" + kUTF8MidlineEllipsis + "3456", "05/99",
-                 kMasterCard, autofill_manager_->GetPackedCreditCardID(7)));
+      kDefaultPageID,
+      Suggestion(std::string("Visa") + kUTF8MidlineEllipsis + "3456", "04/99",
+                 kVisaCard, autofill_manager_->GetPackedCreditCardID(4)),
+      Suggestion(std::string("MasterCard") + kUTF8MidlineEllipsis + "8765",
+                 "10/98", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(5)),
+      Suggestion(std::string("MasterCard") + kUTF8MidlineEllipsis + "3456",
+                 "05/99", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(7)));
 }
 
 // Test that we return profile and credit card suggestions for combined forms.
 TEST_F(AutofillManagerTest, GetAddressAndCreditCardSuggestions) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right address suggestions to the external delegate.
   external_delegate_->CheckSuggestions(
       kDefaultPageID, Suggestion("Charles", "123 Apple St.", "", 1),
       Suggestion("Elvis", "3734 Elvis Presley Blvd.", "", 2));
 
   const int kPageID2 = 2;
   test::CreateTestFormField("Card Number", "cardnumber", "", "text", &field);
   GetAutofillSuggestions(kPageID2, form, field);
 
   // Test that we sent the credit card suggestions to the external delegate.
   external_delegate_->CheckSuggestions(
-      kPageID2, Suggestion("Visa" + kUTF8MidlineEllipsis + "3456",
-                           "04/99", kVisaCard,
-                           autofill_manager_->GetPackedCreditCardID(4)),
-      Suggestion("MasterCard" + kUTF8MidlineEllipsis + "8765", "10/98",
-                 kMasterCard, autofill_manager_->GetPackedCreditCardID(5)));
+      kPageID2,
+      Suggestion(std::string("Visa") + kUTF8MidlineEllipsis + "3456", "04/99",
+                 kVisaCard, autofill_manager_->GetPackedCreditCardID(4)),
+      Suggestion(std::string("MasterCard") + kUTF8MidlineEllipsis + "8765",
+                 "10/98", kMasterCard,
+                 autofill_manager_->GetPackedCreditCardID(5)));
 }
 
 // Test that for non-https forms with both address and credit card fields, we
 // only return address suggestions. Instead of credit card suggestions, we
 // should return a warning explaining that credit card profile suggestions are
 // unavailable when the form is not https.
 TEST_F(AutofillManagerTest, GetAddressAndCreditCardSuggestionsNonHttps) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   CreateTestCreditCardFormData(&form, false, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field = form.fields[0];
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right suggestions to the external delegate.
   external_delegate_->CheckSuggestions(
       kDefaultPageID, Suggestion("Charles", "123 Apple St.", "", 1),
       Suggestion("Elvis", "3734 Elvis Presley Blvd.", "", 2));
 
   test::CreateTestFormField("Card Number", "cardnumber", "", "text", &field);
   const int kPageID2 = 2;
   GetAutofillSuggestions(kPageID2, form, field);
 
   // Test that we sent the right values to the external delegate.
   external_delegate_->CheckSuggestions(
-      kPageID2,
-      Suggestion(
-          l10n_util::GetStringUTF8(IDS_AUTOFILL_WARNING_INSECURE_CONNECTION),
-          "", "", -1));
+      kPageID2, Suggestion(l10n_util::GetStringUTF8(
+                               IDS_AUTOFILL_WARNING_INSECURE_CONNECTION),
+                           "", "", -1));
 
   // Clear the test credit cards and try again -- we shouldn't return a warning.
   personal_data_.ClearCreditCards();
   GetAutofillSuggestions(form, field);
   external_delegate_->CheckNoSuggestions(kDefaultPageID);
 }
 
 // Test that we return autocomplete-like suggestions when trying to autofill
 // already filled forms.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsWhenFormIsAutofilled) {
@@ skipping 29 matching lines @@
   GetAutofillSuggestions(form, field);
 
   // Add some Autocomplete suggestions.
   // This triggers the combined message send.
   std::vector<base::string16> suggestions;
   suggestions.push_back(ASCIIToUTF16("one"));
   suggestions.push_back(ASCIIToUTF16("two"));
   AutocompleteSuggestionsReturned(suggestions);
 
   // Test that we sent the right values to the external delegate.
-  external_delegate_->CheckSuggestions(
-      kDefaultPageID,
-      Suggestion("one", "", "", 0),
-      Suggestion("two", "", "", 0));
+  external_delegate_->CheckSuggestions(kDefaultPageID,
+                                       Suggestion("one", "", "", 0),
+                                       Suggestion("two", "", "", 0));
 }
 
 // Test that we do not return duplicate values drawn from multiple profiles when
 // filling an already filled field.
 TEST_F(AutofillManagerTest, GetFieldSuggestionsWithDuplicateValues) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   // |profile| will be owned by the mock PersonalDataManager.
   std::unique_ptr<AutofillProfile> profile =
       base::MakeUnique<AutofillProfile>();
   test::SetProfileInfo(profile.get(), "Elvis", "", "", "", "", "", "", "", "",
                        "", "", "");
   profile->set_guid("00000000-0000-0000-0000-000000000101");
   autofill_manager_->AddProfile(std::move(profile));
 
   FormFieldData& field = form.fields[0];
   field.is_autofilled = true;
   field.value = ASCIIToUTF16("Elvis");
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate.
-  external_delegate_->CheckSuggestions(
-      kDefaultPageID,
-      Suggestion("Elvis", "", "", 1));
+  external_delegate_->CheckSuggestions(kDefaultPageID,
+                                       Suggestion("Elvis", "", "", 1));
 }
 
 TEST_F(AutofillManagerTest, GetProfileSuggestions_FancyPhone) {
   // Set up our form data.
   FormData form;
   test::CreateTestAddressFormData(&form);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   std::unique_ptr<AutofillProfile> profile =
       base::MakeUnique<AutofillProfile>();
   profile->set_guid("00000000-0000-0000-0000-000000000103");
   profile->SetInfo(AutofillType(NAME_FULL), ASCIIToUTF16("Natty Bumppo"),
                    "en-US");
-  profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER,
-                      ASCIIToUTF16("1800PRAIRIE"));
+  profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16("1800PRAIRIE"));
   autofill_manager_->AddProfile(std::move(profile));
 
   const FormFieldData& field = form.fields[9];
   GetAutofillSuggestions(form, field);
 
   // Test that we sent the right values to the external delegate. Inferred
   // labels include the most private field of those that would be filled.
   external_delegate_->CheckSuggestions(
       kDefaultPageID,
       Suggestion("18007724743", "Natty Bumppo", "", 1),  // 1800PRAIRIE
@@ skipping 14 matching lines @@
     size_t max_length;
     const char* const autocomplete_attribute;
   } test_fields[] = {{"country code", "country_code", 1, "tel-country-code"},
                      {"area code", "area_code", 3, "tel-area-code"},
                      {"phone", "phone_prefix", 3, "tel-local-prefix"},
                      {"-", "phone_suffix", 4, "tel-local-suffix"},
                      {"Phone Extension", "ext", 5, "tel-extension"}};
 
   FormFieldData field;
   for (const auto& test_field : test_fields) {
-    test::CreateTestFormField(
-        test_field.label, test_field.name, "", "text", &field);
+    test::CreateTestFormField(test_field.label, test_field.name, "", "text",
+                              &field);
     field.max_length = test_field.max_length;
     field.autocomplete_attribute = std::string();
     form.fields.push_back(field);
   }
 
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   std::unique_ptr<AutofillProfile> profile =
       base::MakeUnique<AutofillProfile>();
@@ skipping 88 matching lines @@
   CreateTestCreditCardFormData(&form, true, false);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   const char guid[] = "00000000-0000-0000-0000-000000000004";
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
                                      MakeFrontendID(guid, std::string()),
                                      &response_page_id, &response_data);
-  ExpectFilledCreditCardFormElvis(
-      response_page_id, response_data, kDefaultPageID, false);
+  ExpectFilledCreditCardFormElvis(response_page_id, response_data,
+                                  kDefaultPageID, false);
 }
 
 // Test that whitespace is stripped from the credit card number.
 TEST_F(AutofillManagerTest, FillCreditCardForm_StripCardNumberWhitespace) {
   // Same as the SetUp(), but generate Elvis card with whitespace in credit
   // card number.
   personal_data_.CreateTestCreditCardWithWhitespace();
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, false);
@@ skipping 43 matching lines @@
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   const char guid[] = "00000000-0000-0000-0000-000000000007";
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
                                      MakeFrontendID(guid, std::string()),
                                      &response_page_id, &response_data);
   ExpectFilledCreditCardYearMonthWithYearMonth(response_page_id, response_data,
-      kDefaultPageID, false, "", "");
+                                               kDefaultPageID, false, "", "");
 }
 
-
 // Test that we correctly fill a credit card form with month input type.
 // 2. year empty, month non-empty
 TEST_F(AutofillManagerTest, FillCreditCardForm_NoYearMonth) {
   // Same as the SetUp(), but generate 4 credit cards with year month
   // combination.
   personal_data_.CreateTestCreditCardsYearAndMonth("", "04");
   // Set up our form data.
   FormData form;
   CreateTestCreditCardFormData(&form, true, true);
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   const char guid[] = "00000000-0000-0000-0000-000000000007";
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, *form.fields.begin(),
                                      MakeFrontendID(guid, std::string()),
                                      &response_page_id, &response_data);
   ExpectFilledCreditCardYearMonthWithYearMonth(response_page_id, response_data,
-      kDefaultPageID, false, "", "04");
+                                               kDefaultPageID, false, "", "04");
 }
 
 // Test that we correctly fill a credit card form with month input type.
 // 3. year non-empty, month empty
 TEST_F(AutofillManagerTest, FillCreditCardForm_YearNoMonth) {
   // Same as the SetUp(), but generate 4 credit cards with year month
   // combination.
   personal_data_.CreateTestCreditCardsYearAndMonth("2999", "");
   // Set up our form data.
   FormData form;
@@ skipping 93 matching lines @@
 
   // Now fill the credit card data.
   const int kPageID2 = 2;
   const char guid2[] = "00000000-0000-0000-0000-000000000004";
   response_page_id = 0;
   {
     FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields.back(),
                                        MakeFrontendID(guid2, std::string()),
                                        &response_page_id, &response_data);
     SCOPED_TRACE("Credit card");
-    ExpectFilledCreditCardFormElvis(
-        response_page_id, response_data, kPageID2, true);
+    ExpectFilledCreditCardFormElvis(response_page_id, response_data, kPageID2,
+                                    true);
   }
 }
 
 // Test that a field with an unrecognized autocomplete attribute is not filled.
 TEST_F(AutofillManagerTest, FillAddressForm_UnrecognizedAttribute) {
   FormData address_form;
   address_form.name = ASCIIToUTF16("MyForm");
   address_form.origin = GURL("https://myform.com/form.html");
   address_form.action = GURL("https://myform.com/submit.html");
   FormFieldData field;
@@ skipping 292 matching lines @@
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
                                      MakeFrontendID(std::string(), guid),
                                      &response_page_id, &response_data);
 
   // The whole form should be filled as all the fields belong to the same
   // logical section.
   ASSERT_EQ(6U, response_data.fields.size());
   ExpectFilledField("First Name", "firstname", "Elvis", "text",
                     response_data.fields[0]);
-  ExpectFilledField("", "lastname", "Presley", "text",
-                    response_data.fields[1]);
+  ExpectFilledField("", "lastname", "Presley", "text", response_data.fields[1]);
   ExpectFilledField("", "email", "theking@gmail.com", "text",
                     response_data.fields[2]);
   ExpectFilledField("Phone Number", "phonenumber", "12345678901", "tel",
                     response_data.fields[3]);
   ExpectFilledField("", "email_", "theking@gmail.com", "text",
                     response_data.fields[4]);
   ExpectFilledField("Country", "country", "United States", "text",
                     response_data.fields[5]);
 }
 
@@ skipping 15 matching lines @@
   // Fill the first section.
   const char guid[] = "00000000-0000-0000-0000-000000000001";
   int response_page_id = 0;
   FormData response_data;
   FillAutofillFormDataAndSaveResults(kDefaultPageID, form, form.fields[0],
                                      MakeFrontendID(std::string(), guid),
                                      &response_page_id, &response_data);
   {
     SCOPED_TRACE("Address 1");
     // The second address section should be empty.
-    ASSERT_EQ(response_data.fields.size(), 2*kAddressFormSize);
+    ASSERT_EQ(response_data.fields.size(), 2 * kAddressFormSize);
     for (size_t i = kAddressFormSize; i < form.fields.size(); ++i) {
       EXPECT_EQ(base::string16(), response_data.fields[i].value);
     }
 
     // The first address section should be filled with Elvis's data.
     response_data.fields.resize(kAddressFormSize);
     ExpectFilledAddressFormElvis(response_page_id, response_data,
                                  kDefaultPageID, false);
   }
 
   // Fill the second section, with the initiating field somewhere in the middle
   // of the section.
   const int kPageID2 = 2;
   const char guid2[] = "00000000-0000-0000-0000-000000000001";
   ASSERT_LT(9U, kAddressFormSize);
   response_page_id = 0;
   FillAutofillFormDataAndSaveResults(
       kPageID2, form, form.fields[kAddressFormSize + 9],
       MakeFrontendID(std::string(), guid2), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Address 2");
     ASSERT_EQ(response_data.fields.size(), form.fields.size());
 
     // The first address section should be empty.
-    ASSERT_EQ(response_data.fields.size(), 2*kAddressFormSize);
+    ASSERT_EQ(response_data.fields.size(), 2 * kAddressFormSize);
     for (size_t i = 0; i < kAddressFormSize; ++i) {
       EXPECT_EQ(base::string16(), response_data.fields[i].value);
     }
 
     // The second address section should be filled with Elvis's data.
     FormData secondSection = response_data;
     secondSection.fields.erase(secondSection.fields.begin(),
                                secondSection.fields.begin() + kAddressFormSize);
     for (size_t i = 0; i < kAddressFormSize; ++i) {
       // Restore the expected field names.
@@ skipping 104 matching lines @@
                                      MakeFrontendID(std::string(), guid2),
                                      &response_page_id, &response_data);
   {
     SCOPED_TRACE("Billing address");
     EXPECT_EQ(kPageID2, response_page_id);
     EXPECT_EQ(ASCIIToUTF16("MyForm"), response_data.name);
     EXPECT_EQ(GURL("https://myform.com/form.html"), response_data.origin);
     EXPECT_EQ(GURL("https://myform.com/submit.html"), response_data.action);
     ASSERT_EQ(11U, response_data.fields.size());
 
-    ExpectFilledField("", "country", "US", "text",
-                      response_data.fields[0]);
+    ExpectFilledField("", "country", "US", "text", response_data.fields[0]);
     ExpectFilledField("", "firstname", "", "text", response_data.fields[1]);
     ExpectFilledField("", "lastname", "", "text", response_data.fields[2]);
     ExpectFilledField("", "address", "3734 Elvis Presley Blvd.", "text",
                       response_data.fields[3]);
     ExpectFilledField("", "city", "Memphis", "text", response_data.fields[4]);
     ExpectFilledField("", "state", "Tennessee", "text",
                       response_data.fields[5]);
     ExpectFilledField("", "zip", "38116", "text", response_data.fields[6]);
     ExpectFilledField("", "ccname", "", "text", response_data.fields[7]);
     ExpectFilledField("", "ccnumber", "", "text", response_data.fields[8]);
@@ skipping 90 matching lines @@
 
   // Now fill the credit card data.
   const int kPageID2 = 2;
   const char guid2[] = "00000000-0000-0000-0000-000000000004";
   response_page_id = 0;
   FillAutofillFormDataAndSaveResults(kPageID2, form, form.fields.back(),
                                      MakeFrontendID(guid2, std::string()),
                                      &response_page_id, &response_data);
   {
     SCOPED_TRACE("Credit card 1");
-    ExpectFilledCreditCardFormElvis(
-        response_page_id, response_data, kPageID2, true);
+    ExpectFilledCreditCardFormElvis(response_page_id, response_data, kPageID2,
+                                    true);
   }
 
   // Now set the credit card fields to also be auto-filled, and try again to
   // fill the credit card data
   for (std::vector<FormFieldData>::iterator iter = form.fields.begin();
-       iter != form.fields.end();
-       ++iter) {
+       iter != form.fields.end(); ++iter) {
     iter->is_autofilled = true;
   }
 
   const int kPageID3 = 3;
   response_page_id = 0;
   FillAutofillFormDataAndSaveResults(
       kPageID3, form, form.fields[form.fields.size() - 2],
       MakeFrontendID(guid2, std::string()), &response_page_id, &response_data);
   {
     SCOPED_TRACE("Credit card 2");
@@ skipping 14 matching lines @@
   form_with_us_number_max_length.action =
       GURL("http://myform.com/phone_submit.html");
   FormData form_with_autocompletetype = form_with_us_number_max_length;
   form_with_autocompletetype.name = ASCIIToUTF16("MyAutocompletetypePhoneForm");
 
   struct {
     const char* label;
     const char* name;
     size_t max_length;
     const char* autocomplete_attribute;
-  } test_fields[] = {
-    { "country code", "country_code", 1, "tel-country-code" },
-    { "area code", "area_code", 3, "tel-area-code" },
-    { "phone", "phone_prefix", 3, "tel-local-prefix" },
-    { "-", "phone_suffix", 4, "tel-local-suffix" },
-    { "Phone Extension", "ext", 3, "tel-extension" }
-  };
+  } test_fields[] = {{"country code", "country_code", 1, "tel-country-code"},
+                     {"area code", "area_code", 3, "tel-area-code"},
+                     {"phone", "phone_prefix", 3, "tel-local-prefix"},
+                     {"-", "phone_suffix", 4, "tel-local-suffix"},
+                     {"Phone Extension", "ext", 3, "tel-extension"}};
 
   FormFieldData field;
   const size_t default_max_length = field.max_length;
   for (const auto& test_field : test_fields) {
-    test::CreateTestFormField(
-        test_field.label, test_field.name, "", "text", &field);
+    test::CreateTestFormField(test_field.label, test_field.name, "", "text",
+                              &field);
     field.max_length = test_field.max_length;
     field.autocomplete_attribute = std::string();
     form_with_us_number_max_length.fields.push_back(field);
 
     field.max_length = default_max_length;
     field.autocomplete_attribute = test_field.autocomplete_attribute;
     form_with_autocompletetype.fields.push_back(field);
   }
 
   std::vector<FormData> forms;
@@ skipping 450 matching lines @@
   signatures.push_back(form_structure->FormSignatureAsStr());
   signatures.push_back(form_structure2->FormSignatureAsStr());
 
   base::HistogramTester histogram_tester;
   autofill_manager_->OnLoadedServerPredictions(response_string, signatures);
   // Verify that FormStructure::ParseQueryResponse was called (here and below).
   histogram_tester.ExpectBucketCount("Autofill.ServerQueryResponse",
                                      AutofillMetrics::QUERY_RESPONSE_RECEIVED,
                                      1);
   histogram_tester.ExpectBucketCount("Autofill.ServerQueryResponse",
-                                     AutofillMetrics::QUERY_RESPONSE_PARSED,
-                                     1);
+                                     AutofillMetrics::QUERY_RESPONSE_PARSED, 1);
   // We expect the server type to have been applied to the first field of the
   // first form.
   EXPECT_EQ(NAME_FIRST, form_structure->field(0)->Type().GetStorableType());
 
   // We expect the server types to have been applied to the second form.
   EXPECT_EQ(NAME_LAST, form_structure2->field(0)->Type().GetStorableType());
   EXPECT_EQ(NAME_MIDDLE, form_structure2->field(1)->Type().GetStorableType());
   EXPECT_EQ(ADDRESS_HOME_ZIP,
             form_structure2->field(2)->Type().GetStorableType());
 }
@@ skipping 308 matching lines @@
       {"(234)567-8901", PHONE_HOME_CITY_AND_NUMBER},
       {"2345678901", PHONE_HOME_CITY_AND_NUMBER},
       {"1", PHONE_HOME_COUNTRY_CODE},
       {"234", PHONE_HOME_CITY_CODE},
       {"5678901", PHONE_HOME_NUMBER},
       {"567", PHONE_HOME_NUMBER},
       {"8901", PHONE_HOME_NUMBER},
 
       // Test a European profile.
       {"Paris", ADDRESS_HOME_CITY},
-      {"Île de France", ADDRESS_HOME_STATE},  // Exact match
-      {"Ile de France", ADDRESS_HOME_STATE},  // Missing accent.
+      {"Île de France", ADDRESS_HOME_STATE},    // Exact match
+      {"Ile de France", ADDRESS_HOME_STATE},    // Missing accent.
       {"-Ile-de-France-", ADDRESS_HOME_STATE},  // Extra punctuation.
       {"île dÉ FrÃÑÇË", ADDRESS_HOME_STATE},  // Other accents & case mismatch.
       {"75008", ADDRESS_HOME_ZIP},
       {"FR", ADDRESS_HOME_COUNTRY},
       {"France", ADDRESS_HOME_COUNTRY},
       {"33249197070", PHONE_HOME_WHOLE_NUMBER},
       {"+33 2 49 19 70 70", PHONE_HOME_WHOLE_NUMBER},
       {"2 49 19 70 70", PHONE_HOME_CITY_AND_NUMBER},
       {"249197070", PHONE_HOME_CITY_AND_NUMBER},
       {"33", PHONE_HOME_COUNTRY_CODE},
@@ skipping 575 matching lines @@
 
   // Verify whether suggestions are populated correctly for one of the middle
   // credit card number fields when filled partially.
   FormFieldData number_field = form.fields[3];
   number_field.value = ASCIIToUTF16("901");
 
   // Get the suggestions for already filled credit card |number_field|.
   GetAutofillSuggestions(form, number_field);
 
   external_delegate_->CheckSuggestions(
-      kDefaultPageID, Suggestion("Visa" + kUTF8MidlineEllipsis + "3456",
-                                 "04/99", kVisaCard,
-                                 autofill_manager_->GetPackedCreditCardID(4)));
+      kDefaultPageID,
+      Suggestion(std::string("Visa") + kUTF8MidlineEllipsis + "3456", "04/99",
+                 kVisaCard, autofill_manager_->GetPackedCreditCardID(4)));
 }
 
 // Test that inputs detected to be CVC inputs are forced to
 // !should_autocomplete for AutocompleteHistoryManager::OnWillSubmitForm.
 TEST_F(AutofillManagerTest, DontSaveCvcInAutocompleteHistory) {
   FormData form_seen_by_ahm;
   MockAutocompleteHistoryManager* m = RecreateMockAutocompleteHistoryManager();
   EXPECT_CALL(*m, OnWillSubmitForm(_)).WillOnce(SaveArg<0>(&form_seen_by_ahm));
 
   FormData form;
@@ skipping 160 matching lines @@
   credit_card_form.fields[4].value = ASCIIToUTF16("123");
 
   FormSubmitted(credit_card_form);
 
   EXPECT_TRUE(autofill_manager_->credit_card_was_uploaded());
   EXPECT_TRUE(autofill_manager_->GetLocalCreditCards().empty());
   ASSERT_EQ(1U, autofill_manager_->GetCreditCards().size());
   const CreditCard* const saved_card = autofill_manager_->GetCreditCards()[0];
   EXPECT_EQ(CreditCard::OK, saved_card->GetServerStatus());
   EXPECT_EQ(base::ASCIIToUTF16("1111"), saved_card->LastFourDigits());
-  EXPECT_EQ(kVisaCard, saved_card->type());
+  EXPECT_EQ(kVisaCard, saved_card->network());
   EXPECT_EQ(11, saved_card->expiration_month());
   EXPECT_EQ(2017, saved_card->expiration_year());
   EXPECT_EQ(server_id, saved_card->server_id());
   EXPECT_EQ(CreditCard::FULL_SERVER_CARD, saved_card->record_type());
   EXPECT_EQ(base::ASCIIToUTF16(card_number), saved_card->number());
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
-#define MAYBE_UploadCreditCard_FeatureNotEnabled DISABLED_UploadCreditCard_FeatureNotEnabled
+#define MAYBE_UploadCreditCard_FeatureNotEnabled \
+  DISABLED_UploadCreditCard_FeatureNotEnabled
 #else
-#define MAYBE_UploadCreditCard_FeatureNotEnabled UploadCreditCard_FeatureNotEnabled
+#define MAYBE_UploadCreditCard_FeatureNotEnabled \
+  UploadCreditCard_FeatureNotEnabled
 #endif
 TEST_F(AutofillManagerTest, MAYBE_UploadCreditCard_FeatureNotEnabled) {
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(false);
 
   // Create, fill and submit an address form in order to establish a recent
   // profile which can be selected for the upload request.
   FormData address_form;
   test::CreateTestAddressFormData(&address_form);
   FormsSeen(std::vector<FormData>(1, address_form));
@@ skipping 18 matching lines @@
   EXPECT_CALL(autofill_client_, ConfirmSaveCreditCardLocally(_, _));
   FormSubmitted(credit_card_form);
   EXPECT_FALSE(autofill_manager_->credit_card_was_uploaded());
 
   // Verify that no histogram entry was logged called.
   histogram_tester.ExpectTotalCount("Autofill.CardUploadDecisionExpanded", 0);
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
-#define MAYBE_UploadCreditCard_CvcUnavailable DISABLED_UploadCreditCard_CvcUnavailable
+#define MAYBE_UploadCreditCard_CvcUnavailable \
+  DISABLED_UploadCreditCard_CvcUnavailable
 #else
 #define MAYBE_UploadCreditCard_CvcUnavailable UploadCreditCard_CvcUnavailable
 #endif
 TEST_F(AutofillManagerTest, MAYBE_UploadCreditCard_CvcUnavailable) {
   EnableUkmLogging();
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(true);
 
   // Create, fill and submit an address form in order to establish a recent
   // profile which can be selected for the upload request.
@@ skipping 38 matching lines @@
   std::string sample;
   rappor::RapporType type;
   EXPECT_TRUE(rappor_service->GetRecordedSampleForMetric(
       "Autofill.CardUploadNotOfferedNoCvc", &sample, &type));
   EXPECT_EQ("myform.com", sample);
   EXPECT_EQ(rappor::ETLD_PLUS_ONE_RAPPOR_TYPE, type);
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
-#define MAYBE_UploadCreditCard_CvcInvalidLength DISABLED_UploadCreditCard_CvcInvalidLength
+#define MAYBE_UploadCreditCard_CvcInvalidLength \
+  DISABLED_UploadCreditCard_CvcInvalidLength
 #else
-#define MAYBE_UploadCreditCard_CvcInvalidLength UploadCreditCard_CvcInvalidLength
+#define MAYBE_UploadCreditCard_CvcInvalidLength \
+  UploadCreditCard_CvcInvalidLength
 #endif
 TEST_F(AutofillManagerTest, MAYBE_UploadCreditCard_CvcInvalidLength) {
   EnableUkmLogging();
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(true);
 
   // Create, fill and submit an address form in order to establish a recent
   // profile which can be selected for the upload request.
   FormData address_form;
   test::CreateTestAddressFormData(&address_form);
@@ skipping 33 matching lines @@
   std::string sample;
   rappor::RapporType type;
   EXPECT_TRUE(rappor_service->GetRecordedSampleForMetric(
       "Autofill.CardUploadNotOfferedNoCvc", &sample, &type));
   EXPECT_EQ("myform.com", sample);
   EXPECT_EQ(rappor::ETLD_PLUS_ONE_RAPPOR_TYPE, type);
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
-#define MAYBE_UploadCreditCard_MultipleCvcFields DISABLED_UploadCreditCard_MultipleCvcFields
+#define MAYBE_UploadCreditCard_MultipleCvcFields \
+  DISABLED_UploadCreditCard_MultipleCvcFields
 #else
-#define MAYBE_UploadCreditCard_MultipleCvcFields UploadCreditCard_MultipleCvcFields
+#define MAYBE_UploadCreditCard_MultipleCvcFields \
+  UploadCreditCard_MultipleCvcFields
 #endif
 TEST_F(AutofillManagerTest, MAYBE_UploadCreditCard_MultipleCvcFields) {
   EnableUkmLogging();
   autofill_manager_->set_credit_card_upload_enabled(true);
 
   // Remove the profiles that were created in the TestPersonalDataManager
   // constructor because they would result in conflicting names that would
   // prevent the upload.
   personal_data_.ClearAutofillProfiles();
 
@@ skipping 36 matching lines @@
   credit_card_form.fields[5].value = ASCIIToUTF16("123");
 
   base::HistogramTester histogram_tester;
 
   // A CVC value appeared in one of the two CVC fields, upload should happen.
   EXPECT_CALL(autofill_client_, ConfirmSaveCreditCardLocally(_, _)).Times(0);
   FormSubmitted(credit_card_form);
   EXPECT_TRUE(autofill_manager_->credit_card_was_uploaded());
 
   // Verify that the correct histogram entry (and only that) was logged.
-  histogram_tester.ExpectUniqueSample(
-      "Autofill.CardUploadDecisionExpanded",
-      AutofillMetrics::UPLOAD_OFFERED, 1);
+  histogram_tester.ExpectUniqueSample("Autofill.CardUploadDecisionExpanded",
+                                      AutofillMetrics::UPLOAD_OFFERED, 1);
   // Verify that the correct UKM was logged.
   ExpectCardUploadDecisionUkm(AutofillMetrics::UPLOAD_OFFERED);
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
 #define MAYBE_UploadCreditCard_NoCvcFieldOnForm \
   DISABLED_UploadCreditCard_NoCvcFieldOnForm
 #else
 #define MAYBE_UploadCreditCard_NoCvcFieldOnForm \
@@ skipping 125 matching lines @@
   std::string sample;
   rappor::RapporType type;
   EXPECT_TRUE(rappor_service->GetRecordedSampleForMetric(
       "Autofill.CardUploadNotOfferedNoCvc", &sample, &type));
   EXPECT_EQ("myform.com", sample);
   EXPECT_EQ(rappor::ETLD_PLUS_ONE_RAPPOR_TYPE, type);
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
-#define MAYBE_UploadCreditCard_NoProfileAvailable DISABLED_UploadCreditCard_NoProfileAvailable
+#define MAYBE_UploadCreditCard_NoProfileAvailable \
+  DISABLED_UploadCreditCard_NoProfileAvailable
 #else
-#define MAYBE_UploadCreditCard_NoProfileAvailable UploadCreditCard_NoProfileAvailable
+#define MAYBE_UploadCreditCard_NoProfileAvailable \
+  UploadCreditCard_NoProfileAvailable
 #endif
 TEST_F(AutofillManagerTest, MAYBE_UploadCreditCard_NoProfileAvailable) {
   EnableUkmLogging();
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(true);
 
   // Don't fill or submit an address form.
 
   // Set up our credit card form data.
   FormData credit_card_form;
@@ skipping 27 matching lines @@
   std::string sample;
   rappor::RapporType type;
   EXPECT_TRUE(rappor_service->GetRecordedSampleForMetric(
       "Autofill.CardUploadNotOfferedNoAddress", &sample, &type));
   EXPECT_EQ("myform.com", sample);
   EXPECT_EQ(rappor::ETLD_PLUS_ONE_RAPPOR_TYPE, type);
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
-#define MAYBE_UploadCreditCard_CvcUnavailableAndNoProfileAvailable DISABLED_UploadCreditCard_CvcUnavailableAndNoProfileAvailable
+#define MAYBE_UploadCreditCard_CvcUnavailableAndNoProfileAvailable \
+  DISABLED_UploadCreditCard_CvcUnavailableAndNoProfileAvailable
 #else
-#define MAYBE_UploadCreditCard_CvcUnavailableAndNoProfileAvailable UploadCreditCard_CvcUnavailableAndNoProfileAvailable
+#define MAYBE_UploadCreditCard_CvcUnavailableAndNoProfileAvailable \
+  UploadCreditCard_CvcUnavailableAndNoProfileAvailable
 #endif
 TEST_F(AutofillManagerTest,
        MAYBE_UploadCreditCard_CvcUnavailableAndNoProfileAvailable) {
   EnableUkmLogging();
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(true);
 
   // Don't fill or submit an address form.
 
   // Set up our credit card form data.
@@ skipping 30 matching lines @@
   std::string sample;
   rappor::RapporType type;
   EXPECT_TRUE(rappor_service->GetRecordedSampleForMetric(
       "Autofill.CardUploadNotOfferedNoCvc", &sample, &type));
   EXPECT_EQ("myform.com", sample);
   EXPECT_EQ(rappor::ETLD_PLUS_ONE_RAPPOR_TYPE, type);
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
-#define MAYBE_UploadCreditCard_NoNameAvailable DISABLED_UploadCreditCard_NoNameAvailable
+#define MAYBE_UploadCreditCard_NoNameAvailable \
+  DISABLED_UploadCreditCard_NoNameAvailable
 #else
 #define MAYBE_UploadCreditCard_NoNameAvailable UploadCreditCard_NoNameAvailable
 #endif
 TEST_F(AutofillManagerTest, MAYBE_UploadCreditCard_NoNameAvailable) {
   EnableUkmLogging();
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(true);
 
   // Create, fill and submit an address form in order to establish a recent
   // profile which can be selected for the upload request.
@@ skipping 35 matching lines @@
   std::string sample;
   rappor::RapporType type;
   EXPECT_TRUE(rappor_service->GetRecordedSampleForMetric(
       "Autofill.CardUploadNotOfferedNoName", &sample, &type));
   EXPECT_EQ("myform.com", sample);
   EXPECT_EQ(rappor::ETLD_PLUS_ONE_RAPPOR_TYPE, type);
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
-#define MAYBE_UploadCreditCard_ZipCodesConflict DISABLED_UploadCreditCard_ZipCodesConflict
+#define MAYBE_UploadCreditCard_ZipCodesConflict \
+  DISABLED_UploadCreditCard_ZipCodesConflict
 #else
-#define MAYBE_UploadCreditCard_ZipCodesConflict UploadCreditCard_ZipCodesConflict
+#define MAYBE_UploadCreditCard_ZipCodesConflict \
+  UploadCreditCard_ZipCodesConflict
 #endif
 TEST_F(AutofillManagerTest, MAYBE_UploadCreditCard_ZipCodesConflict) {
   EnableUkmLogging();
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(true);
 
   // Create, fill and submit two address forms with different zip codes.
   FormData address_form1, address_form2;
   test::CreateTestAddressFormData(&address_form1);
   test::CreateTestAddressFormData(&address_form2);
@@ skipping 34 matching lines @@
   histogram_tester.ExpectUniqueSample(
       "Autofill.CardUploadDecisionExpanded",
       AutofillMetrics::UPLOAD_NOT_OFFERED_CONFLICTING_ZIPS, 1);
   // Verify that the correct UKM was logged.
   ExpectCardUploadDecisionUkm(
       AutofillMetrics::UPLOAD_NOT_OFFERED_CONFLICTING_ZIPS);
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
-#define MAYBE_UploadCreditCard_ZipCodesHavePrefixMatch DISABLED_UploadCreditCard_ZipCodesHavePrefixMatch
+#define MAYBE_UploadCreditCard_ZipCodesHavePrefixMatch \
+  DISABLED_UploadCreditCard_ZipCodesHavePrefixMatch
 #else
-#define MAYBE_UploadCreditCard_ZipCodesHavePrefixMatch UploadCreditCard_ZipCodesHavePrefixMatch
+#define MAYBE_UploadCreditCard_ZipCodesHavePrefixMatch \
+  UploadCreditCard_ZipCodesHavePrefixMatch
 #endif
 TEST_F(AutofillManagerTest, MAYBE_UploadCreditCard_ZipCodesHavePrefixMatch) {
   EnableUkmLogging();
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(true);
 
   // Create, fill and submit two address forms with different zip codes.
   FormData address_form1, address_form2;
   test::CreateTestAddressFormData(&address_form1);
   test::CreateTestAddressFormData(&address_form2);
@@ skipping 22 matching lines @@
   credit_card_form.fields[4].value = ASCIIToUTF16("123");
 
   base::HistogramTester histogram_tester;
 
   // One zip is a prefix of the other, upload should happen.
   EXPECT_CALL(autofill_client_, ConfirmSaveCreditCardLocally(_, _)).Times(0);
   FormSubmitted(credit_card_form);
   EXPECT_TRUE(autofill_manager_->credit_card_was_uploaded());
 
   // Verify that the correct histogram entry (and only that) was logged.
-  histogram_tester.ExpectUniqueSample(
-      "Autofill.CardUploadDecisionExpanded",
-      AutofillMetrics::UPLOAD_OFFERED, 1);
+  histogram_tester.ExpectUniqueSample("Autofill.CardUploadDecisionExpanded",
+                                      AutofillMetrics::UPLOAD_OFFERED, 1);
   // Verify that the correct UKM was logged.
   ExpectCardUploadDecisionUkm(AutofillMetrics::UPLOAD_OFFERED);
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
-#define MAYBE_UploadCreditCard_NoZipCodeAvailable DISABLED_UploadCreditCard_NoZipCodeAvailable
+#define MAYBE_UploadCreditCard_NoZipCodeAvailable \
+  DISABLED_UploadCreditCard_NoZipCodeAvailable
 #else
-#define MAYBE_UploadCreditCard_NoZipCodeAvailable UploadCreditCard_NoZipCodeAvailable
+#define MAYBE_UploadCreditCard_NoZipCodeAvailable \
+  UploadCreditCard_NoZipCodeAvailable
 #endif
 TEST_F(AutofillManagerTest, MAYBE_UploadCreditCard_NoZipCodeAvailable) {
   EnableUkmLogging();
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(true);
 
   // Create, fill and submit an address form in order to establish a recent
   // profile which can be selected for the upload request.
   FormData address_form;
   test::CreateTestAddressFormData(&address_form);
@@ skipping 30 matching lines @@
   // Verify that the correct histogram entry (and only that) was logged.
   histogram_tester.ExpectUniqueSample(
       "Autofill.CardUploadDecisionExpanded",
       AutofillMetrics::UPLOAD_NOT_OFFERED_NO_ZIP_CODE, 1);
   // Verify that the correct UKM was logged.
   ExpectCardUploadDecisionUkm(AutofillMetrics::UPLOAD_NOT_OFFERED_NO_ZIP_CODE);
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
-#define MAYBE_UploadCreditCard_NamesMatchLoosely DISABLED_UploadCreditCard_NamesMatchLoosely
+#define MAYBE_UploadCreditCard_NamesMatchLoosely \
+  DISABLED_UploadCreditCard_NamesMatchLoosely
 #else
-#define MAYBE_UploadCreditCard_NamesMatchLoosely UploadCreditCard_NamesMatchLoosely
+#define MAYBE_UploadCreditCard_NamesMatchLoosely \
+  UploadCreditCard_NamesMatchLoosely
 #endif
 TEST_F(AutofillManagerTest, MAYBE_UploadCreditCard_NamesMatchLoosely) {
   EnableUkmLogging();
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(true);
 
   // Create, fill and submit two address forms with different names.
   FormData address_form1, address_form2;
   test::CreateTestAddressFormData(&address_form1);
   test::CreateTestAddressFormData(&address_form2);
@@ skipping 25 matching lines @@
   credit_card_form.fields[4].value = ASCIIToUTF16("123");
 
   base::HistogramTester histogram_tester;
 
   // Names match loosely, upload should happen.
   EXPECT_CALL(autofill_client_, ConfirmSaveCreditCardLocally(_, _)).Times(0);
   FormSubmitted(credit_card_form);
   EXPECT_TRUE(autofill_manager_->credit_card_was_uploaded());
 
   // Verify that the correct histogram entry (and only that) was logged.
-  histogram_tester.ExpectUniqueSample(
-      "Autofill.CardUploadDecisionExpanded",
-      AutofillMetrics::UPLOAD_OFFERED, 1);
+  histogram_tester.ExpectUniqueSample("Autofill.CardUploadDecisionExpanded",
+                                      AutofillMetrics::UPLOAD_OFFERED, 1);
   // Verify that the correct UKM was logged.
   ExpectCardUploadDecisionUkm(AutofillMetrics::UPLOAD_OFFERED);
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
-#define MAYBE_UploadCreditCard_NamesHaveToMatch DISABLED_UploadCreditCard_NamesHaveToMatch
+#define MAYBE_UploadCreditCard_NamesHaveToMatch \
+  DISABLED_UploadCreditCard_NamesHaveToMatch
 #else
-#define MAYBE_UploadCreditCard_NamesHaveToMatch UploadCreditCard_NamesHaveToMatch
+#define MAYBE_UploadCreditCard_NamesHaveToMatch \
+  UploadCreditCard_NamesHaveToMatch
 #endif
 TEST_F(AutofillManagerTest, MAYBE_UploadCreditCard_NamesHaveToMatch) {
   EnableUkmLogging();
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(true);
 
   // Create, fill and submit two address forms with different names.
   FormData address_form1, address_form2;
   test::CreateTestAddressFormData(&address_form1);
   test::CreateTestAddressFormData(&address_form2);
@@ skipping 42 matching lines @@
   std::string sample;
   rappor::RapporType type;
   EXPECT_TRUE(rappor_service->GetRecordedSampleForMetric(
       "Autofill.CardUploadNotOfferedConflictingNames", &sample, &type));
   EXPECT_EQ("myform.com", sample);
   EXPECT_EQ(rappor::ETLD_PLUS_ONE_RAPPOR_TYPE, type);
 }
 
 // TODO(crbug.com/666704): Flaky on android_n5x_swarming_rel bot.
 #if defined(OS_ANDROID)
-#define MAYBE_UploadCreditCard_UploadDetailsFails DISABLED_UploadCreditCard_UploadDetailsFails
+#define MAYBE_UploadCreditCard_UploadDetailsFails \
+  DISABLED_UploadCreditCard_UploadDetailsFails
 #else
-#define MAYBE_UploadCreditCard_UploadDetailsFails UploadCreditCard_UploadDetailsFails
+#define MAYBE_UploadCreditCard_UploadDetailsFails \
+  UploadCreditCard_UploadDetailsFails
 #endif
 TEST_F(AutofillManagerTest, MAYBE_UploadCreditCard_UploadDetailsFails) {
   EnableUkmLogging();
   personal_data_.ClearAutofillProfiles();
   autofill_manager_->set_credit_card_upload_enabled(true);
 
   // Anything other than "en-US" will cause GetUploadDetails to return a failure
   // response.
   autofill_manager_->set_app_locale("pt-BR");
 
@@ skipping 109 matching lines @@
   std::vector<FormData> forms(1, form);
   FormsSeen(forms);
 
   FormFieldData field;
   test::CreateTestFormField("Name on Card", "nameoncard", "pres", "text",
                             &field);
   GetAutofillSuggestions(form, field);
 
 #if defined(OS_ANDROID)
   static const std::string kVisaSuggestion =
-      "Visa" + kUTF8MidlineEllipsis + "3456";
+      std::string("Visa") + kUTF8MidlineEllipsis + "3456";
 #else
   static const std::string kVisaSuggestion = "*3456";
 #endif
 
   external_delegate_->CheckSuggestions(
       kDefaultPageID, Suggestion("Elvis Presley", kVisaSuggestion, kVisaCard,
                                  autofill_manager_->GetPackedCreditCardID(4)));
 }
 
 // Verify that typing "lvis" will not match any of the credit card name when
@@ skipping 512 matching lines @@
 
   // Wait for upload to complete (will check expected types as well).
   autofill_manager_->WaitForAsyncUploadProcess();
 
   EXPECT_EQ(signature, autofill_manager_->GetSubmittedFormSignature());
   EXPECT_NE(uploaded_available_types.end(),
             uploaded_available_types.find(autofill::PASSWORD));
 }
 
 }  // namespace autofill