Remove PasswordForm::ssl_valid

chrome/browser/password_manager/password_store_mac_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/password_manager/password_store_mac.h"
 
 #include <stddef.h>
 
 #include <string>
 
@@ skipping 140 matching lines @@
             form->federation_origin);
       } else {
         EXPECT_EQ(WideToUTF16(expectation->password_value),
                   form->password_value);
         EXPECT_TRUE(form->federation_origin.unique());
       }
     } else {
       EXPECT_TRUE(form->blacklisted_by_user);
     }
     EXPECT_EQ(expectation->preferred, form->preferred);
-    EXPECT_EQ(expectation->ssl_valid, form->ssl_valid);
     EXPECT_DOUBLE_EQ(expectation->creation_time,
                      form->date_created.ToDoubleT());
     base::Time created = base::Time::FromDoubleT(expectation->creation_time);
     EXPECT_EQ(
         created + base::TimeDelta::FromDays(
                       password_manager::kTestingDaysAfterPasswordsAreSynced),
         form->date_synced);
     EXPECT_EQ(GURL(password_manager::kTestingIconUrlSpec), form->icon_url);
   }
 }
@@ skipping 156 matching lines @@
 
 #pragma mark -
 
 TEST_F(PasswordStoreMacInternalsTest, TestKeychainToFormTranslation) {
   typedef struct {
     const PasswordForm::Scheme scheme;
     const char* signon_realm;
     const char* origin;
     const wchar_t* username;  // Set to NULL to check for a blacklist entry.
     const wchar_t* password;
-    const bool ssl_valid;
     const int creation_year;
     const int creation_month;
     const int creation_day;
     const int creation_hour;
     const int creation_minute;
     const int creation_second;
   } TestExpectations;
 
   TestExpectations expected[] = {
       {PasswordForm::SCHEME_HTML, "http://some.domain.com/",
-       "http://some.domain.com/", L"joe_user", L"sekrit", false, 2002, 6, 1, 17,
-       15, 0},
+       "http://some.domain.com/", L"joe_user", L"sekrit", 2002, 6, 1, 17, 15,
+       0},
       {PasswordForm::SCHEME_HTML, "http://some.domain.com/",
-       "http://some.domain.com/insecure.html", L"joe_user", L"sekrit", false,
-       1999, 12, 31, 23, 59, 59},
+       "http://some.domain.com/insecure.html", L"joe_user", L"sekrit", 1999, 12,
+       31, 23, 59, 59},
       {PasswordForm::SCHEME_HTML, "https://some.domain.com/",
-       "https://some.domain.com/secure.html", L"secure_user", L"password", true,
-       2010, 9, 8, 7, 6, 5},
+       "https://some.domain.com/secure.html", L"secure_user", L"password", 2010,
+       9, 8, 7, 6, 5},
       {PasswordForm::SCHEME_HTML, "http://dont.remember.com/",
-       "http://dont.remember.com/", NULL, NULL, false, 2000, 1, 1, 0, 0, 0},
+       "http://dont.remember.com/", NULL, NULL, 2000, 1, 1, 0, 0, 0},
       {PasswordForm::SCHEME_HTML, "http://dont.remember.com/",
-       "http://dont.remember.com/", NULL, NULL, false, 2000, 1, 1, 0, 0, 0},
+       "http://dont.remember.com/", NULL, NULL, 2000, 1, 1, 0, 0, 0},
       {PasswordForm::SCHEME_HTML, "https://dont.remember.com/",
-       "https://dont.remember.com/", NULL, NULL, true, 2000, 1, 1, 0, 0, 0},
+       "https://dont.remember.com/", NULL, NULL, 2000, 1, 1, 0, 0, 0},
       {PasswordForm::SCHEME_BASIC, "http://some.domain.com:4567/low_security",
        "http://some.domain.com:4567/insecure.html", L"basic_auth_user",
-       L"basic", false, 1998, 03, 30, 10, 00, 00},
+       L"basic", 1998, 03, 30, 10, 00, 00},
       {PasswordForm::SCHEME_DIGEST, "https://some.domain.com/high_security",
-       "https://some.domain.com/", L"digest_auth_user", L"digest", true, 1998,
-       3, 30, 10, 0, 0},
+       "https://some.domain.com/", L"digest_auth_user", L"digest", 1998, 3, 30,
+       10, 0, 0},
       // This one gives us an invalid date, which we will treat as a "NULL" date
       // which is 1601.
       {PasswordForm::SCHEME_OTHER, "http://a.server.com/",
-       "http://a.server.com/", L"abc", L"123", false, 1601, 1, 1, 0, 0, 0},
+       "http://a.server.com/", L"abc", L"123", 1601, 1, 1, 0, 0, 0},
       {PasswordForm::SCHEME_HTML, "android://hash@com.domain.some/", "",
-       L"joe_user", L"secret", true, 2015, 5, 15, 14, 13, 12},
+       L"joe_user", L"secret", 2015, 5, 15, 14, 13, 12},
   };
 
   for (unsigned int i = 0; i < arraysize(expected); ++i) {
     SCOPED_TRACE(testing::Message("In iteration ") << i);
     // Create our fake KeychainItemRef; see MockAppleKeychain docs.
     SecKeychainItemRef keychain_item =
         reinterpret_cast<SecKeychainItemRef>(i + 1);
     PasswordForm form;
     bool parsed = internal_keychain_helpers::FillPasswordFormFromKeychainItem(
         *keychain_, keychain_item, &form, true);
 
     EXPECT_TRUE(parsed);
 
     EXPECT_EQ(expected[i].scheme, form.scheme);
     EXPECT_EQ(GURL(expected[i].origin), form.origin);
-    EXPECT_EQ(expected[i].ssl_valid, form.ssl_valid);
     EXPECT_EQ(std::string(expected[i].signon_realm), form.signon_realm);
     if (expected[i].username) {
       EXPECT_EQ(WideToUTF16(expected[i].username), form.username_value);
       EXPECT_EQ(WideToUTF16(expected[i].password), form.password_value);
       EXPECT_FALSE(form.blacklisted_by_user);
     } else {
       EXPECT_TRUE(form.blacklisted_by_user);
     }
     base::Time::Exploded exploded_time;
     form.date_created.UTCExplode(&exploded_time);
@@ skipping 18 matching lines @@
 TEST_F(PasswordStoreMacInternalsTest, TestKeychainSearch) {
   struct TestDataAndExpectation {
     const PasswordFormData data;
     const size_t expected_fill_matches;
     const size_t expected_merge_matches;
   };
   // Most fields are left blank because we don't care about them for searching.
   TestDataAndExpectation test_data[] = {
       // An HTML form we've seen.
       {{PasswordForm::SCHEME_HTML, "http://some.domain.com/", NULL, NULL, NULL,
-        NULL, NULL, L"joe_user", NULL, false, false, 0},
+        NULL, NULL, L"joe_user", NULL, false, 0},
        2,
        2},
       {{PasswordForm::SCHEME_HTML, "http://some.domain.com/", NULL, NULL, NULL,
-        NULL, NULL, L"wrong_user", NULL, false, false, 0},
+        NULL, NULL, L"wrong_user", NULL, false, 0},
        2,
        0},
       // An HTML form we haven't seen
       {{PasswordForm::SCHEME_HTML, "http://www.unseendomain.com/", NULL, NULL,
-        NULL, NULL, NULL, L"joe_user", NULL, false, false, 0},
+        NULL, NULL, NULL, L"joe_user", NULL, false, 0},
        0,
        0},
       // Basic auth that should match.
       {{PasswordForm::SCHEME_BASIC, "http://some.domain.com:4567/low_security",
-        NULL, NULL, NULL, NULL, NULL, L"basic_auth_user", NULL, false, false,
-        0},
+        NULL, NULL, NULL, NULL, NULL, L"basic_auth_user", NULL, false, 0},
        1,
        1},
       // Basic auth with the wrong port.
       {{PasswordForm::SCHEME_BASIC, "http://some.domain.com:1111/low_security",
-        NULL, NULL, NULL, NULL, NULL, L"basic_auth_user", NULL, false, false,
-        0},
+        NULL, NULL, NULL, NULL, NULL, L"basic_auth_user", NULL, false, 0},
        0,
        0},
       // Digest auth we've saved under https, visited with http.
       {{PasswordForm::SCHEME_DIGEST, "http://some.domain.com/high_security",
-        NULL, NULL, NULL, NULL, NULL, L"digest_auth_user", NULL, false, false,
-        0},
+        NULL, NULL, NULL, NULL, NULL, L"digest_auth_user", NULL, false, 0},
        0,
        0},
       // Digest auth that should match.
       {{PasswordForm::SCHEME_DIGEST, "https://some.domain.com/high_security",
-        NULL, NULL, NULL, NULL, NULL, L"wrong_user", NULL, false, true, 0},
+        NULL, NULL, NULL, NULL, NULL, L"wrong_user", NULL, false, 0},
        1,
        0},
       // Digest auth with the wrong domain.
       {{PasswordForm::SCHEME_DIGEST, "https://some.domain.com/other_domain",
-        NULL, NULL, NULL, NULL, NULL, L"digest_auth_user", NULL, false, true,
-        0},
+        NULL, NULL, NULL, NULL, NULL, L"digest_auth_user", NULL, false, 0},
        0,
        0},
       // Android credentials (both legacy ones with origin, and without).
       {{PasswordForm::SCHEME_HTML, "android://hash@com.domain.some/",
         "android://hash@com.domain.some/", NULL, NULL, NULL, NULL, L"joe_user",
-        NULL, false, true, 0},
+        NULL, false, 0},
        1,
        1},
       {{PasswordForm::SCHEME_HTML, "android://hash@com.domain.some/", NULL,
-        NULL, NULL, NULL, NULL, L"joe_user", NULL, false, true, 0},
+        NULL, NULL, NULL, NULL, L"joe_user", NULL, false, 0},
        1,
        1},
       // Federated logins do not have a corresponding Keychain entry, and should
       // not match the username/password stored for the same application. Note
       // that it will match for filling, however, because that part does not
       // know
       // that it is a federated login.
       {{PasswordForm::SCHEME_HTML, "android://hash@com.domain.some/", NULL,
         NULL, NULL, NULL, NULL, L"joe_user",
-        password_manager::kTestingFederatedLoginMarker, false, true, 0},
+        password_manager::kTestingFederatedLoginMarker, false, 0},
        1,
        0},
       /// Garbage forms should have no matches.
       {{PasswordForm::SCHEME_HTML, "foo/bar/baz", NULL, NULL, NULL, NULL, NULL,
-        NULL, NULL, false, false, 0},
+        NULL, NULL, false, 0},
        0,
        0},
   };
 
   MacKeychainPasswordFormAdapter keychain_adapter(keychain_);
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_);
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
   for (unsigned int i = 0; i < arraysize(test_data); ++i) {
     std::unique_ptr<PasswordForm> query_form =
         CreatePasswordFormFromDataForTesting(test_data[i].data);
@@ skipping 56 matching lines @@
   GURL signon_gurl = GURL(form->signon_realm);
   form->signon_realm = signon_gurl.ReplaceComponents(replacement).spec();
 }
 
 TEST_F(PasswordStoreMacInternalsTest, TestKeychainExactSearch) {
   MacKeychainPasswordFormAdapter keychain_adapter(keychain_);
 
   PasswordFormData base_form_data[] = {
       {PasswordForm::SCHEME_HTML, "http://some.domain.com/",
        "http://some.domain.com/insecure.html", NULL, NULL, NULL, NULL,
-       L"joe_user", NULL, true, false, 0},
+       L"joe_user", NULL, true, 0},
       {PasswordForm::SCHEME_BASIC, "http://some.domain.com:4567/low_security",
        "http://some.domain.com:4567/insecure.html", NULL, NULL, NULL, NULL,
-       L"basic_auth_user", NULL, true, false, 0},
+       L"basic_auth_user", NULL, true, 0},
       {PasswordForm::SCHEME_DIGEST, "https://some.domain.com/high_security",
        "https://some.domain.com", NULL, NULL, NULL, NULL, L"digest_auth_user",
-       NULL, true, true, 0},
+       NULL, true, 0},
   };
 
   for (unsigned int i = 0; i < arraysize(base_form_data); ++i) {
     // Create a base form and make sure we find a match.
     std::unique_ptr<PasswordForm> base_form =
         CreatePasswordFormFromDataForTesting(base_form_data[i]);
     EXPECT_TRUE(keychain_adapter.HasPasswordsMergeableWithForm(*base_form));
     EXPECT_TRUE(keychain_adapter.HasPasswordExactlyMatchingForm(*base_form));
 
     // Make sure that the matching isn't looser than it should be by checking
@@ skipping 32 matching lines @@
 
 TEST_F(PasswordStoreMacInternalsTest, TestKeychainAdd) {
   struct TestDataAndExpectation {
     PasswordFormData data;
     bool should_succeed;
   };
   TestDataAndExpectation test_data[] = {
       // Test a variety of scheme/port/protocol/path variations.
       {{PasswordForm::SCHEME_HTML, "http://web.site.com/",
         "http://web.site.com/path/to/page.html", NULL, NULL, NULL, NULL,
-        L"anonymous", L"knock-knock", false, false, 0},
+        L"anonymous", L"knock-knock", false, 0},
        true},
       {{PasswordForm::SCHEME_HTML, "https://web.site.com/",
         "https://web.site.com/", NULL, NULL, NULL, NULL, L"admin", L"p4ssw0rd",
-        false, false, 0},
+        false, 0},
        true},
       {{PasswordForm::SCHEME_BASIC, "http://a.site.com:2222/therealm",
         "http://a.site.com:2222/", NULL, NULL, NULL, NULL, L"username",
-        L"password", false, false, 0},
+        L"password", false, 0},
        true},
       {{PasswordForm::SCHEME_DIGEST, "https://digest.site.com/differentrealm",
         "https://digest.site.com/secure.html", NULL, NULL, NULL, NULL,
-        L"testname", L"testpass", false, false, 0},
+        L"testname", L"testpass", false, 0},
        true},
       // Test that Android credentials can be stored. Also check the legacy form
       // when |origin| was still filled with the Android URI (and not left
       // empty).
       {{PasswordForm::SCHEME_HTML, "android://hash@com.example.alpha/", "",
-        NULL, NULL, NULL, NULL, L"joe_user", L"password", false, true, 0},
+        NULL, NULL, NULL, NULL, L"joe_user", L"password", false, 0},
        true},
       {{PasswordForm::SCHEME_HTML, "android://hash@com.example.beta/",
         "android://hash@com.example.beta/", NULL, NULL, NULL, NULL,
-        L"jane_user", L"password2", false, true, 0},
+        L"jane_user", L"password2", false, 0},
        true},
       // Make sure that garbage forms are rejected.
       {{PasswordForm::SCHEME_HTML, "gobbledygook", "gobbledygook", NULL, NULL,
-        NULL, NULL, L"anonymous", L"knock-knock", false, false, 0},
+        NULL, NULL, L"anonymous", L"knock-knock", false, 0},
        false},
       // Test that failing to update a duplicate (forced using the magic failure
       // password; see MockAppleKeychain::ItemModifyAttributesAndData) is
       // reported.
       {{PasswordForm::SCHEME_HTML, "http://some.domain.com",
         "http://some.domain.com/insecure.html", NULL, NULL, NULL, NULL,
-        L"joe_user", L"fail_me", false, false, 0},
+        L"joe_user", L"fail_me", false, 0},
        false},
   };
 
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_);
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
 
   for (unsigned int i = 0; i < arraysize(test_data); ++i) {
     std::unique_ptr<PasswordForm> in_form =
         CreatePasswordFormFromDataForTesting(test_data[i].data);
     bool add_succeeded = owned_keychain_adapter.AddPassword(*in_form);
@@ skipping 13 matching lines @@
     PasswordFormData data = {PasswordForm::SCHEME_HTML,
                              "http://some.domain.com",
                              "http://some.domain.com/insecure.html",
                              NULL,
                              NULL,
                              NULL,
                              NULL,
                              L"joe_user",
                              L"updated_password",
                              false,
-                             false,
                              0};
     std::unique_ptr<PasswordForm> update_form =
         CreatePasswordFormFromDataForTesting(data);
     MacKeychainPasswordFormAdapter keychain_adapter(keychain_);
     EXPECT_TRUE(keychain_adapter.AddPassword(*update_form));
     SecKeychainItemRef keychain_item = reinterpret_cast<SecKeychainItemRef>(2);
     PasswordForm stored_form;
     internal_keychain_helpers::FillPasswordFormFromKeychainItem(
         *keychain_, keychain_item, &stored_form, true);
     EXPECT_EQ(update_form->password_value, stored_form.password_value);
   }
 }
 
 TEST_F(PasswordStoreMacInternalsTest, TestKeychainRemove) {
   struct TestDataAndExpectation {
     PasswordFormData data;
     bool should_succeed;
   };
   TestDataAndExpectation test_data[] = {
       // Test deletion of an item that we add.
       {{PasswordForm::SCHEME_HTML, "http://web.site.com/",
         "http://web.site.com/path/to/page.html", NULL, NULL, NULL, NULL,
-        L"anonymous", L"knock-knock", false, false, 0},
+        L"anonymous", L"knock-knock", false, 0},
        true},
       // Test that Android credentials can be removed. Also check the legacy
-      // case
-      // when |origin| was still filled with the Android URI (and not left
+      // case when |origin| was still filled with the Android URI (and not left
       // empty).
       {{PasswordForm::SCHEME_HTML, "android://hash@com.example.alpha/", "",
-        NULL, NULL, NULL, NULL, L"joe_user", L"secret", false, true, 0},
+        NULL, NULL, NULL, NULL, L"joe_user", L"secret", false, 0},
        true},
       {{PasswordForm::SCHEME_HTML, "android://hash@com.example.beta/",
         "android://hash@com.example.beta/", NULL, NULL, NULL, NULL,
-        L"jane_user", L"secret", false, true, 0},
+        L"jane_user", L"secret", false, 0},
        true},
       // Make sure we don't delete items we don't own.
       {{PasswordForm::SCHEME_HTML, "http://some.domain.com/",
         "http://some.domain.com/insecure.html", NULL, NULL, NULL, NULL,
-        L"joe_user", NULL, true, false, 0},
+        L"joe_user", NULL, true, 0},
        false},
   };
 
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_);
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
 
   // Add our test items (except the last one) so that we can delete them.
   for (unsigned int i = 0; i + 1 < arraysize(test_data); ++i) {
     std::unique_ptr<PasswordForm> add_form =
         CreatePasswordFormFromDataForTesting(test_data[i].data);
@@ skipping 19 matching lines @@
   base_form.username_value = ASCIIToUTF16("joe_user");
 
   {
     // Check that everything unimportant can be changed.
     PasswordForm different_form(base_form);
     different_form.username_element = ASCIIToUTF16("username");
     different_form.submit_element = ASCIIToUTF16("submit");
     different_form.username_element = ASCIIToUTF16("password");
     different_form.password_value = ASCIIToUTF16("sekrit");
     different_form.action = GURL("http://some.domain.com/action.cgi");
-    different_form.ssl_valid = true;
     different_form.preferred = true;
     different_form.date_created = base::Time::Now();
     EXPECT_TRUE(
         FormsMatchForMerge(base_form, different_form, STRICT_FORM_MATCH));
 
     // Check that path differences don't prevent a match.
     base_form.origin = GURL("http://some.domain.com/other_page.html");
     EXPECT_TRUE(
         FormsMatchForMerge(base_form, different_form, STRICT_FORM_MATCH));
   }
@@ skipping 49 matching lines @@
   PasswordFormData keychain_user_1 = {PasswordForm::SCHEME_HTML,
                                       "http://some.domain.com/",
                                       "http://some.domain.com/",
                                       "",
                                       L"",
                                       L"",
                                       L"",
                                       L"joe_user",
                                       L"sekrit",
                                       false,
-                                      false,
                                       1010101010};
   PasswordFormData keychain_user_1_with_path = {
       PasswordForm::SCHEME_HTML,
       "http://some.domain.com/",
       "http://some.domain.com/page.html",
       "",
       L"",
       L"",
       L"",
       L"joe_user",
       L"otherpassword",
       false,
-      false,
       1010101010};
   PasswordFormData keychain_user_2 = {PasswordForm::SCHEME_HTML,
                                       "http://some.domain.com/",
                                       "http://some.domain.com/",
                                       "",
                                       L"",
                                       L"",
                                       L"",
                                       L"john.doe",
                                       L"sesame",
                                       false,
-                                      false,
                                       958739876};
   PasswordFormData keychain_blacklist = {PasswordForm::SCHEME_HTML,
                                          "http://some.domain.com/",
                                          "http://some.domain.com/",
                                          "",
                                          L"",
                                          L"",
                                          L"",
                                          NULL,
                                          NULL,
                                          false,
-                                         false,
                                          1010101010};
   PasswordFormData keychain_android = {PasswordForm::SCHEME_HTML,
                                        "android://hash@com.domain.some/",
                                        "",
                                        "",
                                        L"",
                                        L"",
                                        L"",
                                        L"joe_user",
                                        L"secret",
                                        false,
-                                       true,
                                        1234567890};
 
   PasswordFormData db_user_1 = {PasswordForm::SCHEME_HTML,
                                 "http://some.domain.com/",
                                 "http://some.domain.com/",
                                 "http://some.domain.com/action.cgi",
                                 L"submit",
                                 L"username",
                                 L"password",
                                 L"joe_user",
                                 L"",
                                 true,
-                                false,
                                 1212121212};
   PasswordFormData db_user_1_with_path = {
       PasswordForm::SCHEME_HTML,
       "http://some.domain.com/",
       "http://some.domain.com/page.html",
       "http://some.domain.com/handlepage.cgi",
       L"submit",
       L"username",
       L"password",
       L"joe_user",
       L"",
       true,
-      false,
       1234567890};
   PasswordFormData db_user_3_with_path = {
       PasswordForm::SCHEME_HTML,
       "http://some.domain.com/",
       "http://some.domain.com/page.html",
       "http://some.domain.com/handlepage.cgi",
       L"submit",
       L"username",
       L"password",
       L"second-account",
       L"",
       true,
-      false,
       1240000000};
   PasswordFormData database_blacklist_with_path = {
       PasswordForm::SCHEME_HTML,
       "http://some.domain.com/",
       "http://some.domain.com/path.html",
       "http://some.domain.com/action.cgi",
       L"submit",
       L"username",
       L"password",
       NULL,
       NULL,
       true,
-      false,
       1212121212};
   PasswordFormData db_android = {PasswordForm::SCHEME_HTML,
                                  "android://hash@com.domain.some/",
                                  "android://hash@com.domain.some/",
                                  "",
                                  L"",
                                  L"",
                                  L"",
                                  L"joe_user",
                                  L"",
                                  false,
-                                 true,
                                  1234567890};
   PasswordFormData db_federated = {
       PasswordForm::SCHEME_HTML,
       "android://hash@com.domain.some/",
       "android://hash@com.domain.some/",
       "",
       L"",
       L"",
       L"",
       L"joe_user",
       password_manager::kTestingFederatedLoginMarker,
       false,
-      true,
       3434343434};
 
   PasswordFormData merged_user_1 = {PasswordForm::SCHEME_HTML,
                                     "http://some.domain.com/",
                                     "http://some.domain.com/",
                                     "http://some.domain.com/action.cgi",
                                     L"submit",
                                     L"username",
                                     L"password",
                                     L"joe_user",
                                     L"sekrit",
                                     true,
-                                    false,
                                     1212121212};
   PasswordFormData merged_user_1_with_db_path = {
       PasswordForm::SCHEME_HTML,
       "http://some.domain.com/",
       "http://some.domain.com/page.html",
       "http://some.domain.com/handlepage.cgi",
       L"submit",
       L"username",
       L"password",
       L"joe_user",
       L"sekrit",
       true,
-      false,
       1234567890};
   PasswordFormData merged_user_1_with_both_paths = {
       PasswordForm::SCHEME_HTML,
       "http://some.domain.com/",
       "http://some.domain.com/page.html",
       "http://some.domain.com/handlepage.cgi",
       L"submit",
       L"username",
       L"password",
       L"joe_user",
       L"otherpassword",
       true,
-      false,
       1234567890};
   PasswordFormData merged_android = {PasswordForm::SCHEME_HTML,
                                      "android://hash@com.domain.some/",
                                      "android://hash@com.domain.some/",
                                      "",
                                      L"",
                                      L"",
                                      L"",
                                      L"joe_user",
                                      L"secret",
                                      false,
-                                     true,
                                      1234567890};
 
   // Build up the big multi-dimensional array of data sets that will actually
   // drive the test. Use vectors rather than arrays so that initialization is
   // simple.
   enum {
     KEYCHAIN_INPUT = 0,
     DATABASE_INPUT,
     MERGE_OUTPUT,
     KEYCHAIN_OUTPUT,
@@ skipping 88 matching lines @@
                 test_case);
     CHECK_FORMS(merged_forms.get(), test_data[MERGE_OUTPUT][test_case],
                 test_case);
   }
 }
 
 TEST_F(PasswordStoreMacInternalsTest, TestPasswordBulkLookup) {
   PasswordFormData db_data[] = {
       {PasswordForm::SCHEME_HTML, "http://some.domain.com/",
        "http://some.domain.com/", "http://some.domain.com/action.cgi",
-       L"submit", L"username", L"password", L"joe_user", L"", true, false,
-       1212121212},
+       L"submit", L"username", L"password", L"joe_user", L"", true, 1212121212},
       {PasswordForm::SCHEME_HTML, "http://some.domain.com/",
        "http://some.domain.com/page.html",
        "http://some.domain.com/handlepage.cgi", L"submit", L"username",
-       L"password", L"joe_user", L"", true, false, 1234567890},
+       L"password", L"joe_user", L"", true, 1234567890},
       {PasswordForm::SCHEME_HTML, "http://some.domain.com/",
        "http://some.domain.com/page.html",
        "http://some.domain.com/handlepage.cgi", L"submit", L"username",
-       L"password", L"second-account", L"", true, false, 1240000000},
+       L"password", L"second-account", L"", true, 1240000000},
       {PasswordForm::SCHEME_HTML, "http://dont.remember.com/",
        "http://dont.remember.com/", "http://dont.remember.com/handlepage.cgi",
-       L"submit", L"username", L"password", L"joe_user", L"", true, false,
-       1240000000},
+       L"submit", L"username", L"password", L"joe_user", L"", true, 1240000000},
       {PasswordForm::SCHEME_HTML, "http://some.domain.com/",
        "http://some.domain.com/path.html", "http://some.domain.com/action.cgi",
-       L"submit", L"username", L"password", NULL, NULL, true, false,
-       1212121212},
+       L"submit", L"username", L"password", NULL, NULL, true, 1212121212},
   };
   ScopedVector<autofill::PasswordForm> database_forms;
   for (unsigned int i = 0; i < arraysize(db_data); ++i) {
     database_forms.push_back(
         CreatePasswordFormFromDataForTesting(db_data[i]).release());
   }
   ScopedVector<autofill::PasswordForm> merged_forms;
   internal_keychain_helpers::GetPasswordsForForms(*keychain_, &database_forms,
                                                   &merged_forms);
   EXPECT_EQ(2U, database_forms.size());
   ASSERT_EQ(3U, merged_forms.size());
   EXPECT_EQ(ASCIIToUTF16("sekrit"), merged_forms[0]->password_value);
   EXPECT_EQ(ASCIIToUTF16("sekrit"), merged_forms[1]->password_value);
   EXPECT_TRUE(merged_forms[2]->blacklisted_by_user);
 }
 
 TEST_F(PasswordStoreMacInternalsTest, TestBlacklistedFiltering) {
   PasswordFormData db_data[] = {
       {PasswordForm::SCHEME_HTML, "http://dont.remember.com/",
        "http://dont.remember.com/", "http://dont.remember.com/handlepage.cgi",
        L"submit", L"username", L"password", L"joe_user", L"non_empty_password",
-       true, false, 1240000000},
+       true, 1240000000},
       {PasswordForm::SCHEME_HTML, "https://dont.remember.com/",
        "https://dont.remember.com/",
        "https://dont.remember.com/handlepage_secure.cgi", L"submit",
        L"username", L"password", L"joe_user", L"non_empty_password", true,
-       false, 1240000000},
+       1240000000},
   };
   ScopedVector<autofill::PasswordForm> database_forms;
   for (unsigned int i = 0; i < arraysize(db_data); ++i) {
     database_forms.push_back(
         CreatePasswordFormFromDataForTesting(db_data[i]).release());
   }
   ScopedVector<autofill::PasswordForm> merged_forms;
   internal_keychain_helpers::GetPasswordsForForms(*keychain_, &database_forms,
                                                   &merged_forms);
   EXPECT_EQ(2U, database_forms.size());
@@ skipping 65 matching lines @@
 
 TEST_F(PasswordStoreMacInternalsTest, TestPasswordGetAll) {
   MacKeychainPasswordFormAdapter keychain_adapter(keychain_);
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_);
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
 
   // Add a few passwords of various types so that we own some.
   PasswordFormData owned_password_data[] = {
       {PasswordForm::SCHEME_HTML, "http://web.site.com/",
        "http://web.site.com/path/to/page.html", NULL, NULL, NULL, NULL,
-       L"anonymous", L"knock-knock", false, false, 0},
+       L"anonymous", L"knock-knock", false, 0},
       {PasswordForm::SCHEME_BASIC, "http://a.site.com:2222/therealm",
        "http://a.site.com:2222/", NULL, NULL, NULL, NULL, L"username",
-       L"password", false, false, 0},
+       L"password", false, 0},
       {PasswordForm::SCHEME_DIGEST, "https://digest.site.com/differentrealm",
        "https://digest.site.com/secure.html", NULL, NULL, NULL, NULL,
-       L"testname", L"testpass", false, false, 0},
+       L"testname", L"testpass", false, 0},
   };
   for (unsigned int i = 0; i < arraysize(owned_password_data); ++i) {
     std::unique_ptr<PasswordForm> form =
         CreatePasswordFormFromDataForTesting(owned_password_data[i]);
     owned_keychain_adapter.AddPassword(*form);
   }
 
   ScopedVector<autofill::PasswordForm> all_passwords =
       keychain_adapter.GetAllPasswordFormPasswords();
   EXPECT_EQ(9 + arraysize(owned_password_data), all_passwords.size());
@@ skipping 160 matching lines @@
   PasswordFormData joint_data = {PasswordForm::SCHEME_HTML,
                                  "http://some.domain.com/",
                                  "http://some.domain.com/insecure.html",
                                  "login.cgi",
                                  L"username",
                                  L"password",
                                  L"submit",
                                  L"joe_user",
                                  L"sekrit",
                                  true,
-                                 false,
                                  1};
   std::unique_ptr<PasswordForm> joint_form =
       CreatePasswordFormFromDataForTesting(joint_data);
   EXPECT_EQ(AddChangeForForm(*joint_form), login_db()->AddLogin(*joint_form));
   MockAppleKeychain::KeychainTestData joint_keychain_data = {
       kSecAuthenticationTypeHTMLForm,
       "some.domain.com",
       kSecProtocolTypeHTTP,
       "/insecure.html",
       0,
@@ skipping 22 matching lines @@
     PasswordFormData form_data;
     const char* password;  // NULL indicates no entry should be present.
   };
 
   // Make a series of update calls.
   UpdateData updates[] = {
       // Update the keychain+db passwords (the normal password update case).
       {
           {PasswordForm::SCHEME_HTML, "http://some.domain.com/",
            "http://some.domain.com/insecure.html", "login.cgi", L"username",
-           L"password", L"submit", L"joe_user", L"53krit", true, false, 2},
+           L"password", L"submit", L"joe_user", L"53krit", true, 2},
           "53krit",
       },
       // Update the keychain-only password; this simulates the initial use of a
       // password stored by another browsers.
       {
           {PasswordForm::SCHEME_HTML, "http://keychain.only.com/",
            "http://keychain.only.com/login.html", "login.cgi", L"username",
-           L"password", L"submit", L"keychain", L"only", true, false, 2},
+           L"password", L"submit", L"keychain", L"only", true, 2},
           "only",
       },
       // Update a password that doesn't exist in either location. This tests the
       // case where a form is filled, then the stored login is removed, then the
       // form is submitted.
       {
           {PasswordForm::SCHEME_HTML, "http://different.com/",
            "http://different.com/index.html", "login.cgi", L"username",
-           L"password", L"submit", L"abc", L"123", true, false, 2},
+           L"password", L"submit", L"abc", L"123", true, 2},
           NULL,
       },
   };
   for (unsigned int i = 0; i < arraysize(updates); ++i) {
     std::unique_ptr<PasswordForm> form =
         CreatePasswordFormFromDataForTesting(updates[i].form_data);
     store_->UpdateLogin(*form);
   }
 
   FinishAsyncProcessing();
@@ skipping 42 matching lines @@
   PasswordFormData www_form_data = {PasswordForm::SCHEME_HTML,
                                     "http://www.facebook.com/",
                                     "http://www.facebook.com/index.html",
                                     "login",
                                     L"username",
                                     L"password",
                                     L"submit",
                                     L"joe_user",
                                     L"sekrit",
                                     true,
-                                    false,
                                     1};
   std::unique_ptr<PasswordForm> www_form =
       CreatePasswordFormFromDataForTesting(www_form_data);
   EXPECT_EQ(AddChangeForForm(*www_form), login_db()->AddLogin(*www_form));
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain());
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
   owned_keychain_adapter.AddPassword(*www_form);
 
   // 2. Get a password for m.facebook.com.
   PasswordForm m_form(*www_form);
@@ skipping 72 matching lines @@
       PasswordForm::SCHEME_HTML,
       "http://www.facebook.com/",
       "http://www.facebook.com/index.html",
       "login",
       L"submit",
       L"username",
       L"password",
       L"joe_user",
       L"sekrit",
       true,
-      false,
       0};
   // The old form doesn't have elements names.
   PasswordFormData www_form_data_facebook_old = {
       PasswordForm::SCHEME_HTML,
       "http://www.facebook.com/",
       "http://www.facebook.com/index.html",
       "login",
       L"",
       L"",
       L"",
       L"joe_user",
       L"oldsekrit",
       true,
-      false,
       0};
   PasswordFormData www_form_data_other = {PasswordForm::SCHEME_HTML,
                                           "http://different.com/",
                                           "http://different.com/index.html",
                                           "login",
                                           L"submit",
                                           L"username",
                                           L"password",
                                           L"different_joe_user",
                                           L"sekrit",
                                           true,
-                                          false,
                                           0};
   std::unique_ptr<PasswordForm> form_facebook =
       CreatePasswordFormFromDataForTesting(www_form_data_facebook);
   std::unique_ptr<PasswordForm> form_facebook_old =
       CreatePasswordFormFromDataForTesting(www_form_data_facebook_old);
   std::unique_ptr<PasswordForm> form_other =
       CreatePasswordFormFromDataForTesting(www_form_data_other);
   base::Time now = base::Time::Now();
   base::Time next_day = now + base::TimeDelta::FromDays(1);
   if (check_created) {
@@ skipping 83 matching lines @@
       PasswordForm::SCHEME_HTML,
       "http://www.facebook.com/",
       "http://www.facebook.com/index.html",
       "login",
       L"submit",
       L"username",
       L"password",
       L"joe_user",
       L"sekrit",
       true,
-      false,
       0};
   std::unique_ptr<PasswordForm> form_facebook =
       CreatePasswordFormFromDataForTesting(www_form_data_facebook);
   form_facebook->skip_zero_click = false;
 
   PasswordFormData www_form_data_google = {
       PasswordForm::SCHEME_HTML,
       "http://www.google.com/",
       "http://www.google.com/foo/bar/index.html",
       "login",
       L"submit",
       L"username",
       L"password",
       L"joe_user",
       L"sekrit",
       true,
-      false,
       0};
   std::unique_ptr<PasswordForm> form_google =
       CreatePasswordFormFromDataForTesting(www_form_data_google);
   form_google->skip_zero_click = false;
 
   // Add the zero-clickable forms to the database.
   PasswordsChangeObserver observer(store());
   store()->AddLogin(*form_facebook);
   store()->AddLogin(*form_google);
   EXPECT_CALL(observer, OnLoginsChanged(GetAddChangeList(*form_facebook)));
@@ skipping 41 matching lines @@
   PasswordFormData www_form_data1 = {PasswordForm::SCHEME_HTML,
                                      "http://www.facebook.com/",
                                      "http://www.facebook.com/index.html",
                                      "login",
                                      L"username",
                                      L"password",
                                      L"submit",
                                      L"joe_user",
                                      L"sekrit",
                                      true,
-                                     false,
                                      1};
   std::unique_ptr<PasswordForm> www_form =
       CreatePasswordFormFromDataForTesting(www_form_data1);
   EXPECT_TRUE(owned_keychain_adapter.AddPassword(*www_form));
 
   // Add a password from the current profile.
   PasswordFormData www_form_data2 = {PasswordForm::SCHEME_HTML,
                                      "http://www.facebook.com/",
                                      "http://www.facebook.com/index.html",
                                      "login",
                                      L"username",
                                      L"password",
                                      L"submit",
                                      L"not_joe_user",
                                      L"12345",
                                      true,
-                                     false,
                                      1};
   www_form = CreatePasswordFormFromDataForTesting(www_form_data2);
   store_->AddLogin(*www_form);
   FinishAsyncProcessing();
 
   ScopedVector<PasswordForm> matching_items;
   EXPECT_TRUE(login_db()->GetLogins(*www_form, &matching_items));
   EXPECT_EQ(1u, matching_items.size());
 
   store_->RemoveLoginsCreatedBetween(base::Time(), base::Time(),
@@ skipping 29 matching lines @@
   PasswordFormData www_form_data = {PasswordForm::SCHEME_HTML,
                                     "http://www.facebook.com/",
                                     "http://www.facebook.com/index.html",
                                     "login",
                                     L"username",
                                     L"password",
                                     L"submit",
                                     L"joe_user",
                                     L"",
                                     true,
-                                    false,
                                     1};
   std::unique_ptr<PasswordForm> www_form(
       CreatePasswordFormFromDataForTesting(www_form_data));
   EXPECT_EQ(AddChangeForForm(*www_form), login_db()->AddLogin(*www_form));
 
   // 2. Get a PSL-matched password for m.facebook.com. The observer isn't
   // notified because the form isn't in the database.
   PasswordForm m_form(*www_form);
   m_form.signon_realm = "http://m.facebook.com";
   m_form.origin = GURL("http://m.facebook.com/index.html");
@@ skipping 161 matching lines @@
   histogram_tester_->ExpectUniqueSample(
       "PasswordManager.KeychainMigration.NumPasswordsOnFailure", 1, 1);
   histogram_tester_->ExpectUniqueSample(
       "PasswordManager.KeychainMigration.NumFailedPasswords", 1, 1);
   histogram_tester_->ExpectUniqueSample(
       "PasswordManager.KeychainMigration.NumChromeOwnedInaccessiblePasswords",
       2, 1);
   // Don't test the encryption key access.
   histogram_tester_.reset();
 }