Update webdata files to take advantage of DLOG(FATAL) in

chrome/browser/webdata/autofill_table_unittest.cc

 // Copyright (c) 2011 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 <vector>
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
@@ skipping 555 matching lines @@
 
   // Get the 'Home' profile.
   AutofillProfile* db_profile;
   ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(
       home_profile.guid(), &db_profile));
   EXPECT_EQ(home_profile, *db_profile);
   sql::Statement s_home(db.GetSQLConnection()->GetUniqueStatement(
       "SELECT date_modified "
       "FROM autofill_profiles WHERE guid=?"));
   s_home.BindString(0, home_profile.guid());
-  ASSERT_TRUE(s_home);
+  ASSERT_TRUE(s_home.is_valid());
   ASSERT_TRUE(s_home.Step());
   EXPECT_GE(s_home.ColumnInt64(0), pre_creation_time.ToTimeT());
   EXPECT_LE(s_home.ColumnInt64(0), post_creation_time.ToTimeT());
   EXPECT_FALSE(s_home.Step());
   delete db_profile;
 
   // Add a 'Billing' profile.
   AutofillProfile billing_profile = home_profile;
   billing_profile.set_guid(guid::GenerateGUID());
   billing_profile.SetInfo(ADDRESS_HOME_LINE1,
                           ASCIIToUTF16("5678 Bottom Street"));
   billing_profile.SetInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("suite 3"));
 
   pre_creation_time = Time::Now();
   EXPECT_TRUE(db.GetAutofillTable()->AddAutofillProfile(billing_profile));
   post_creation_time = Time::Now();
 
   // Get the 'Billing' profile.
   ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(
       billing_profile.guid(), &db_profile));
   EXPECT_EQ(billing_profile, *db_profile);
   sql::Statement s_billing(db.GetSQLConnection()->GetUniqueStatement(
       "SELECT date_modified FROM autofill_profiles WHERE guid=?"));
   s_billing.BindString(0, billing_profile.guid());
-  ASSERT_TRUE(s_billing);
+  ASSERT_TRUE(s_billing.is_valid());
   ASSERT_TRUE(s_billing.Step());
   EXPECT_GE(s_billing.ColumnInt64(0), pre_creation_time.ToTimeT());
   EXPECT_LE(s_billing.ColumnInt64(0), post_creation_time.ToTimeT());
   EXPECT_FALSE(s_billing.Step());
   delete db_profile;
 
   // Update the 'Billing' profile, name only.
   billing_profile.SetInfo(NAME_FIRST, ASCIIToUTF16("Jane"));
   Time pre_modification_time = Time::Now();
   EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(
       billing_profile));
   Time post_modification_time = Time::Now();
   ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(
       billing_profile.guid(), &db_profile));
   EXPECT_EQ(billing_profile, *db_profile);
   sql::Statement s_billing_updated(db.GetSQLConnection()->GetUniqueStatement(
       "SELECT date_modified FROM autofill_profiles WHERE guid=?"));
   s_billing_updated.BindString(0, billing_profile.guid());
-  ASSERT_TRUE(s_billing_updated);
+  ASSERT_TRUE(s_billing_updated.is_valid());
   ASSERT_TRUE(s_billing_updated.Step());
   EXPECT_GE(s_billing_updated.ColumnInt64(0),
             pre_modification_time.ToTimeT());
   EXPECT_LE(s_billing_updated.ColumnInt64(0),
             post_modification_time.ToTimeT());
   EXPECT_FALSE(s_billing_updated.Step());
   delete db_profile;
 
   // Update the 'Billing' profile.
   billing_profile.SetInfo(NAME_FIRST, ASCIIToUTF16("Janice"));
@@ skipping 11 matching lines @@
   Time pre_modification_time_2 = Time::Now();
   EXPECT_TRUE(db.GetAutofillTable()->UpdateAutofillProfileMulti(
       billing_profile));
   Time post_modification_time_2 = Time::Now();
   ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(
       billing_profile.guid(), &db_profile));
   EXPECT_EQ(billing_profile, *db_profile);
   sql::Statement s_billing_updated_2(db.GetSQLConnection()->GetUniqueStatement(
       "SELECT date_modified FROM autofill_profiles WHERE guid=?"));
   s_billing_updated_2.BindString(0, billing_profile.guid());
-  ASSERT_TRUE(s_billing_updated_2);
+  ASSERT_TRUE(s_billing_updated_2.is_valid());
   ASSERT_TRUE(s_billing_updated_2.Step());
   EXPECT_GE(s_billing_updated_2.ColumnInt64(0),
             pre_modification_time_2.ToTimeT());
   EXPECT_LE(s_billing_updated_2.ColumnInt64(0),
             post_modification_time_2.ToTimeT());
   EXPECT_FALSE(s_billing_updated_2.Step());
   delete db_profile;
 
   // Remove the 'Billing' profile.
   EXPECT_TRUE(db.GetAutofillTable()->RemoveAutofillProfile(
@@ skipping 280 matching lines @@
   // Get the 'Work' credit card.
   CreditCard* db_creditcard;
   ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(work_creditcard.guid(),
                                                    &db_creditcard));
   EXPECT_EQ(work_creditcard, *db_creditcard);
   sql::Statement s_work(db.GetSQLConnection()->GetUniqueStatement(
       "SELECT guid, name_on_card, expiration_month, expiration_year, "
       "card_number_encrypted, date_modified "
       "FROM credit_cards WHERE guid=?"));
   s_work.BindString(0, work_creditcard.guid());
-  ASSERT_TRUE(s_work);
+  ASSERT_TRUE(s_work.is_valid());
   ASSERT_TRUE(s_work.Step());
   EXPECT_GE(s_work.ColumnInt64(5), pre_creation_time.ToTimeT());
   EXPECT_LE(s_work.ColumnInt64(5), post_creation_time.ToTimeT());
   EXPECT_FALSE(s_work.Step());
   delete db_creditcard;
 
   // Add a 'Target' credit card.
   CreditCard target_creditcard;
   target_creditcard.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Jack Torrance"));
   target_creditcard.SetInfo(CREDIT_CARD_NUMBER,
                             ASCIIToUTF16("1111222233334444"));
   target_creditcard.SetInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("06"));
   target_creditcard.SetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2012"));
 
   pre_creation_time = Time::Now();
   EXPECT_TRUE(db.GetAutofillTable()->AddCreditCard(target_creditcard));
   post_creation_time = Time::Now();
   ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(target_creditcard.guid(),
                                                    &db_creditcard));
   EXPECT_EQ(target_creditcard, *db_creditcard);
   sql::Statement s_target(db.GetSQLConnection()->GetUniqueStatement(
       "SELECT guid, name_on_card, expiration_month, expiration_year, "
       "card_number_encrypted, date_modified "
       "FROM credit_cards WHERE guid=?"));
   s_target.BindString(0, target_creditcard.guid());
-  ASSERT_TRUE(s_target);
+  ASSERT_TRUE(s_target.is_valid());
   ASSERT_TRUE(s_target.Step());
   EXPECT_GE(s_target.ColumnInt64(5), pre_creation_time.ToTimeT());
   EXPECT_LE(s_target.ColumnInt64(5), post_creation_time.ToTimeT());
   EXPECT_FALSE(s_target.Step());
   delete db_creditcard;
 
   // Update the 'Target' credit card.
   target_creditcard.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Charles Grady"));
   Time pre_modification_time = Time::Now();
   EXPECT_TRUE(db.GetAutofillTable()->UpdateCreditCard(target_creditcard));
   Time post_modification_time = Time::Now();
   ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(target_creditcard.guid(),
                                                    &db_creditcard));
   EXPECT_EQ(target_creditcard, *db_creditcard);
   sql::Statement s_target_updated(db.GetSQLConnection()->GetUniqueStatement(
       "SELECT guid, name_on_card, expiration_month, expiration_year, "
       "card_number_encrypted, date_modified "
       "FROM credit_cards WHERE guid=?"));
   s_target_updated.BindString(0, target_creditcard.guid());
-  ASSERT_TRUE(s_target_updated);
+  ASSERT_TRUE(s_target_updated.is_valid());
   ASSERT_TRUE(s_target_updated.Step());
   EXPECT_GE(s_target_updated.ColumnInt64(5), pre_modification_time.ToTimeT());
   EXPECT_LE(s_target_updated.ColumnInt64(5), post_modification_time.ToTimeT());
   EXPECT_FALSE(s_target_updated.Step());
   delete db_creditcard;
 
   // Remove the 'Target' credit card.
   EXPECT_TRUE(db.GetAutofillTable()->RemoveCreditCard(
       target_creditcard.guid()));
   EXPECT_FALSE(db.GetAutofillTable()->GetCreditCard(target_creditcard.guid(),
@@ skipping 17 matching lines @@
   profile.SetInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("CA"));
   profile.SetInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("90025"));
   profile.SetInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
   profile.SetInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16("18181234567"));
   db.GetAutofillTable()->AddAutofillProfile(profile);
 
   // Set a mocked value for the profile's creation time.
   const time_t mock_creation_date = Time::Now().ToTimeT() - 13;
   sql::Statement s_mock_creation_date(db.GetSQLConnection()->GetUniqueStatement(
       "UPDATE autofill_profiles SET date_modified = ?"));
-  ASSERT_TRUE(s_mock_creation_date);
+  ASSERT_TRUE(s_mock_creation_date.is_valid());
   s_mock_creation_date.BindInt64(0, mock_creation_date);
   ASSERT_TRUE(s_mock_creation_date.Run());
 
   // Get the profile.
   AutofillProfile* tmp_profile;
   ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
                                                         &tmp_profile));
   scoped_ptr<AutofillProfile> db_profile(tmp_profile);
   EXPECT_EQ(profile, *db_profile);
   sql::Statement s_original(db.GetSQLConnection()->GetUniqueStatement(
       "SELECT date_modified FROM autofill_profiles"));
-  ASSERT_TRUE(s_original);
+  ASSERT_TRUE(s_original.is_valid());
   ASSERT_TRUE(s_original.Step());
   EXPECT_EQ(mock_creation_date, s_original.ColumnInt64(0));
   EXPECT_FALSE(s_original.Step());
 
   // Now, update the profile and save the update to the database.
   // The modification date should change to reflect the update.
   profile.SetInfo(EMAIL_ADDRESS, ASCIIToUTF16("js@smith.xyz"));
   db.GetAutofillTable()->UpdateAutofillProfileMulti(profile);
 
   // Get the profile.
   ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
                                                         &tmp_profile));
   db_profile.reset(tmp_profile);
   EXPECT_EQ(profile, *db_profile);
   sql::Statement s_updated(db.GetSQLConnection()->GetUniqueStatement(
       "SELECT date_modified FROM autofill_profiles"));
-  ASSERT_TRUE(s_updated);
+  ASSERT_TRUE(s_updated.is_valid());
   ASSERT_TRUE(s_updated.Step());
   EXPECT_LT(mock_creation_date, s_updated.ColumnInt64(0));
   EXPECT_FALSE(s_updated.Step());
 
   // Set a mocked value for the profile's modification time.
   const time_t mock_modification_date = Time::Now().ToTimeT() - 7;
   sql::Statement s_mock_modification_date(
       db.GetSQLConnection()->GetUniqueStatement(
           "UPDATE autofill_profiles SET date_modified = ?"));
-  ASSERT_TRUE(s_mock_modification_date);
+  ASSERT_TRUE(s_mock_modification_date.is_valid());
   s_mock_modification_date.BindInt64(0, mock_modification_date);
   ASSERT_TRUE(s_mock_modification_date.Run());
 
   // Finally, call into |UpdateAutofillProfileMulti()| without changing the
   // profile.  The modification date should not change.
   db.GetAutofillTable()->UpdateAutofillProfileMulti(profile);
 
   // Get the profile.
   ASSERT_TRUE(db.GetAutofillTable()->GetAutofillProfile(profile.guid(),
                                                         &tmp_profile));
   db_profile.reset(tmp_profile);
   EXPECT_EQ(profile, *db_profile);
   sql::Statement s_unchanged(db.GetSQLConnection()->GetUniqueStatement(
       "SELECT date_modified FROM autofill_profiles"));
-  ASSERT_TRUE(s_unchanged);
+  ASSERT_TRUE(s_unchanged.is_valid());
   ASSERT_TRUE(s_unchanged.Step());
   EXPECT_EQ(mock_modification_date, s_unchanged.ColumnInt64(0));
   EXPECT_FALSE(s_unchanged.Step());
 }
 
 TEST_F(AutofillTableTest, UpdateCreditCard) {
   WebDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   // Add a credit card to the db.
   CreditCard credit_card;
   credit_card.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Jack Torrance"));
   credit_card.SetInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("1234567890123456"));
   credit_card.SetInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("04"));
   credit_card.SetInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2013"));
   db.GetAutofillTable()->AddCreditCard(credit_card);
 
   // Set a mocked value for the credit card's creation time.
   const time_t mock_creation_date = Time::Now().ToTimeT() - 13;
   sql::Statement s_mock_creation_date(db.GetSQLConnection()->GetUniqueStatement(
       "UPDATE credit_cards SET date_modified = ?"));
-  ASSERT_TRUE(s_mock_creation_date);
+  ASSERT_TRUE(s_mock_creation_date.is_valid());
   s_mock_creation_date.BindInt64(0, mock_creation_date);
   ASSERT_TRUE(s_mock_creation_date.Run());
 
   // Get the credit card.
   CreditCard* tmp_credit_card;
   ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(credit_card.guid(),
                                                    &tmp_credit_card));
   scoped_ptr<CreditCard> db_credit_card(tmp_credit_card);
   EXPECT_EQ(credit_card, *db_credit_card);
   sql::Statement s_original(db.GetSQLConnection()->GetUniqueStatement(
       "SELECT date_modified FROM credit_cards"));
-  ASSERT_TRUE(s_original);
+  ASSERT_TRUE(s_original.is_valid());
   ASSERT_TRUE(s_original.Step());
   EXPECT_EQ(mock_creation_date, s_original.ColumnInt64(0));
   EXPECT_FALSE(s_original.Step());
 
   // Now, update the credit card and save the update to the database.
   // The modification date should change to reflect the update.
   credit_card.SetInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("01"));
   db.GetAutofillTable()->UpdateCreditCard(credit_card);
 
   // Get the credit card.
   ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(credit_card.guid(),
                                                    &tmp_credit_card));
   db_credit_card.reset(tmp_credit_card);
   EXPECT_EQ(credit_card, *db_credit_card);
   sql::Statement s_updated(db.GetSQLConnection()->GetUniqueStatement(
       "SELECT date_modified FROM credit_cards"));
-  ASSERT_TRUE(s_updated);
+  ASSERT_TRUE(s_updated.is_valid());
   ASSERT_TRUE(s_updated.Step());
   EXPECT_LT(mock_creation_date, s_updated.ColumnInt64(0));
   EXPECT_FALSE(s_updated.Step());
 
   // Set a mocked value for the credit card's modification time.
   const time_t mock_modification_date = Time::Now().ToTimeT() - 7;
   sql::Statement s_mock_modification_date(
       db.GetSQLConnection()->GetUniqueStatement(
           "UPDATE credit_cards SET date_modified = ?"));
-  ASSERT_TRUE(s_mock_modification_date);
+  ASSERT_TRUE(s_mock_modification_date.is_valid());
   s_mock_modification_date.BindInt64(0, mock_modification_date);
   ASSERT_TRUE(s_mock_modification_date.Run());
 
   // Finally, call into |UpdateCreditCard()| without changing the credit card.
   // The modification date should not change.
   db.GetAutofillTable()->UpdateCreditCard(credit_card);
 
   // Get the profile.
   ASSERT_TRUE(db.GetAutofillTable()->GetCreditCard(credit_card.guid(),
                                                    &tmp_credit_card));
   db_credit_card.reset(tmp_credit_card);
   EXPECT_EQ(credit_card, *db_credit_card);
   sql::Statement s_unchanged(db.GetSQLConnection()->GetUniqueStatement(
       "SELECT date_modified FROM credit_cards"));
-  ASSERT_TRUE(s_unchanged);
+  ASSERT_TRUE(s_unchanged.is_valid());
   ASSERT_TRUE(s_unchanged.Step());
   EXPECT_EQ(mock_modification_date, s_unchanged.ColumnInt64(0));
   EXPECT_FALSE(s_unchanged.Step());
 }
 
 TEST_F(AutofillTableTest, RemoveAutofillProfilesAndCreditCardsModifiedBetween) {
   WebDatabase db;
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   // Populate the autofill_profiles and credit_cards tables.
@@ skipping 28 matching lines @@
   std::vector<std::string> credit_card_guids;
   db.GetAutofillTable()->RemoveAutofillProfilesAndCreditCardsModifiedBetween(
       Time::FromTimeT(17), Time::FromTimeT(41),
       &profile_guids, &credit_card_guids);
   ASSERT_EQ(2UL, profile_guids.size());
   EXPECT_EQ("00000000-0000-0000-0000-000000000001", profile_guids[0]);
   EXPECT_EQ("00000000-0000-0000-0000-000000000002", profile_guids[1]);
   sql::Statement s_autofill_profiles_bounded(
       db.GetSQLConnection()->GetUniqueStatement(
           "SELECT date_modified FROM autofill_profiles"));
-  ASSERT_TRUE(s_autofill_profiles_bounded);
+  ASSERT_TRUE(s_autofill_profiles_bounded.is_valid());
   ASSERT_TRUE(s_autofill_profiles_bounded.Step());
   EXPECT_EQ(11, s_autofill_profiles_bounded.ColumnInt64(0));
   ASSERT_TRUE(s_autofill_profiles_bounded.Step());
   EXPECT_EQ(41, s_autofill_profiles_bounded.ColumnInt64(0));
   ASSERT_TRUE(s_autofill_profiles_bounded.Step());
   EXPECT_EQ(51, s_autofill_profiles_bounded.ColumnInt64(0));
   ASSERT_TRUE(s_autofill_profiles_bounded.Step());
   EXPECT_EQ(61, s_autofill_profiles_bounded.ColumnInt64(0));
   EXPECT_FALSE(s_autofill_profiles_bounded.Step());
   ASSERT_EQ(3UL, credit_card_guids.size());
   EXPECT_EQ("00000000-0000-0000-0000-000000000006", credit_card_guids[0]);
   EXPECT_EQ("00000000-0000-0000-0000-000000000007", credit_card_guids[1]);
   EXPECT_EQ("00000000-0000-0000-0000-000000000008", credit_card_guids[2]);
   sql::Statement s_credit_cards_bounded(
       db.GetSQLConnection()->GetUniqueStatement(
           "SELECT date_modified FROM credit_cards"));
-  ASSERT_TRUE(s_credit_cards_bounded);
+  ASSERT_TRUE(s_credit_cards_bounded.is_valid());
   ASSERT_TRUE(s_credit_cards_bounded.Step());
   EXPECT_EQ(47, s_credit_cards_bounded.ColumnInt64(0));
   ASSERT_TRUE(s_credit_cards_bounded.Step());
   EXPECT_EQ(57, s_credit_cards_bounded.ColumnInt64(0));
   ASSERT_TRUE(s_credit_cards_bounded.Step());
   EXPECT_EQ(67, s_credit_cards_bounded.ColumnInt64(0));
   EXPECT_FALSE(s_credit_cards_bounded.Step());
 
   // Remove all entries modified on or after time 51 (unbounded range).
   db.GetAutofillTable()->RemoveAutofillProfilesAndCreditCardsModifiedBetween(
       Time::FromTimeT(51), Time(),
       &profile_guids, &credit_card_guids);
   ASSERT_EQ(2UL, profile_guids.size());
   EXPECT_EQ("00000000-0000-0000-0000-000000000004", profile_guids[0]);
   EXPECT_EQ("00000000-0000-0000-0000-000000000005", profile_guids[1]);
   sql::Statement s_autofill_profiles_unbounded(
       db.GetSQLConnection()->GetUniqueStatement(
           "SELECT date_modified FROM autofill_profiles"));
-  ASSERT_TRUE(s_autofill_profiles_unbounded);
+  ASSERT_TRUE(s_autofill_profiles_unbounded.is_valid());
   ASSERT_TRUE(s_autofill_profiles_unbounded.Step());
   EXPECT_EQ(11, s_autofill_profiles_unbounded.ColumnInt64(0));
   ASSERT_TRUE(s_autofill_profiles_unbounded.Step());
   EXPECT_EQ(41, s_autofill_profiles_unbounded.ColumnInt64(0));
   EXPECT_FALSE(s_autofill_profiles_unbounded.Step());
   ASSERT_EQ(2UL, credit_card_guids.size());
   EXPECT_EQ("00000000-0000-0000-0000-000000000010", credit_card_guids[0]);
   EXPECT_EQ("00000000-0000-0000-0000-000000000011", credit_card_guids[1]);
   sql::Statement s_credit_cards_unbounded(
       db.GetSQLConnection()->GetUniqueStatement(
           "SELECT date_modified FROM credit_cards"));
-  ASSERT_TRUE(s_credit_cards_unbounded);
+  ASSERT_TRUE(s_credit_cards_unbounded.is_valid());
   ASSERT_TRUE(s_credit_cards_unbounded.Step());
   EXPECT_EQ(47, s_credit_cards_unbounded.ColumnInt64(0));
   EXPECT_FALSE(s_credit_cards_unbounded.Step());
 
   // Remove all remaining entries.
   db.GetAutofillTable()->RemoveAutofillProfilesAndCreditCardsModifiedBetween(
       Time(), Time(),
       &profile_guids, &credit_card_guids);
   ASSERT_EQ(2UL, profile_guids.size());
   EXPECT_EQ("00000000-0000-0000-0000-000000000000", profile_guids[0]);
   EXPECT_EQ("00000000-0000-0000-0000-000000000003", profile_guids[1]);
   sql::Statement s_autofill_profiles_empty(
       db.GetSQLConnection()->GetUniqueStatement(
           "SELECT date_modified FROM autofill_profiles"));
-  ASSERT_TRUE(s_autofill_profiles_empty);
+  ASSERT_TRUE(s_autofill_profiles_empty.is_valid());
   EXPECT_FALSE(s_autofill_profiles_empty.Step());
   ASSERT_EQ(1UL, credit_card_guids.size());
   EXPECT_EQ("00000000-0000-0000-0000-000000000009", credit_card_guids[0]);
   sql::Statement s_credit_cards_empty(
       db.GetSQLConnection()->GetUniqueStatement(
           "SELECT date_modified FROM credit_cards"));
-  ASSERT_TRUE(s_credit_cards_empty);
+  ASSERT_TRUE(s_credit_cards_empty.is_valid());
   EXPECT_FALSE(s_credit_cards_empty.Step());
 }
 
 TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_NoResults) {
   WebDatabase db;
 
   ASSERT_EQ(sql::INIT_OK, db.Init(file_));
 
   std::vector<AutofillEntry> entries;
   ASSERT_TRUE(db.GetAutofillTable()->GetAllAutofillEntries(&entries));
@@ skipping 138 matching lines @@
 
   // make sure the lists of entries match
   ASSERT_EQ(expected_entries.size(), entry_set.size());
   AutofillEntrySetIterator it;
   for (it = entry_set.begin(); it != entry_set.end(); it++) {
     expected_entries.erase(*it);
   }
 
   EXPECT_EQ(0U, expected_entries.size());
 }