Home | History | Annotate | Download | only in webdata 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <vector>
      6 
      7 #include "base/files/file_util.h"
      8 #include "base/files/scoped_temp_dir.h"
      9 #include "base/guid.h"
     10 #include "base/path_service.h"
     11 #include "base/strings/string_number_conversions.h"
     12 #include "base/strings/string_util.h"
     13 #include "base/strings/utf_string_conversions.h"
     14 #include "base/time/time.h"
     15 #include "components/autofill/core/browser/autofill_profile.h"
     16 #include "components/autofill/core/browser/autofill_type.h"
     17 #include "components/autofill/core/browser/credit_card.h"
     18 #include "components/autofill/core/browser/webdata/autofill_change.h"
     19 #include "components/autofill/core/browser/webdata/autofill_entry.h"
     20 #include "components/autofill/core/browser/webdata/autofill_table.h"
     21 #include "components/autofill/core/common/form_field_data.h"
     22 #include "components/os_crypt/os_crypt.h"
     23 #include "components/webdata/common/web_database.h"
     24 #include "sql/statement.h"
     25 #include "testing/gtest/include/gtest/gtest.h"
     26 
     27 using base::ASCIIToUTF16;
     28 using base::Time;
     29 using base::TimeDelta;
     30 
     31 namespace autofill {
     32 
     33 // So we can compare AutofillKeys with EXPECT_EQ().
     34 std::ostream& operator<<(std::ostream& os, const AutofillKey& key) {
     35   return os << base::UTF16ToASCII(key.name()) << ", "
     36             << base::UTF16ToASCII(key.value());
     37 }
     38 
     39 // So we can compare AutofillChanges with EXPECT_EQ().
     40 std::ostream& operator<<(std::ostream& os, const AutofillChange& change) {
     41   switch (change.type()) {
     42     case AutofillChange::ADD: {
     43       os << "ADD";
     44       break;
     45     }
     46     case AutofillChange::UPDATE: {
     47       os << "UPDATE";
     48       break;
     49     }
     50     case AutofillChange::REMOVE: {
     51       os << "REMOVE";
     52       break;
     53     }
     54   }
     55   return os << " " << change.key();
     56 }
     57 
     58 namespace {
     59 
     60 typedef std::set<AutofillEntry,
     61     bool (*)(const AutofillEntry&, const AutofillEntry&)> AutofillEntrySet;
     62 typedef AutofillEntrySet::iterator AutofillEntrySetIterator;
     63 
     64 bool CompareAutofillEntries(const AutofillEntry& a, const AutofillEntry& b) {
     65   int compVal = a.key().name().compare(b.key().name());
     66   if (compVal != 0)
     67     return compVal < 0;
     68 
     69   compVal = a.key().value().compare(b.key().value());
     70   if (compVal != 0)
     71     return compVal < 0;
     72 
     73   if (a.date_created() != b.date_created())
     74     return a.date_created() < b.date_created();
     75 
     76   return a.date_last_used() < b.date_last_used();
     77 }
     78 
     79 AutofillEntry MakeAutofillEntry(const char* name,
     80                                 const char* value,
     81                                 time_t date_created,
     82                                 time_t date_last_used) {
     83   if (date_last_used < 0)
     84     date_last_used = date_created;
     85   return AutofillEntry(AutofillKey(ASCIIToUTF16(name), ASCIIToUTF16(value)),
     86                        Time::FromTimeT(date_created),
     87                        Time::FromTimeT(date_last_used));
     88 }
     89 
     90 // Checks |actual| and |expected| contain the same elements.
     91 void CompareAutofillEntrySets(const AutofillEntrySet& actual,
     92                               const AutofillEntrySet& expected) {
     93   ASSERT_EQ(expected.size(), actual.size());
     94   size_t count = 0;
     95   for (AutofillEntrySet::const_iterator it = actual.begin();
     96        it != actual.end(); ++it) {
     97     count += expected.count(*it);
     98   }
     99   EXPECT_EQ(actual.size(), count);
    100 }
    101 
    102 int GetAutofillEntryCount(const base::string16& name,
    103                           const base::string16& value,
    104                           WebDatabase* db) {
    105   sql::Statement s(db->GetSQLConnection()->GetUniqueStatement(
    106       "SELECT count FROM autofill WHERE name = ? AND value = ?"));
    107   s.BindString16(0, name);
    108   s.BindString16(1, value);
    109   s.Step();
    110   return s.ColumnInt(0);
    111 }
    112 
    113 }  // namespace
    114 
    115 class AutofillTableTest : public testing::Test {
    116  public:
    117   AutofillTableTest() {}
    118   virtual ~AutofillTableTest() {}
    119 
    120  protected:
    121   virtual void SetUp() {
    122 #if defined(OS_MACOSX)
    123     OSCrypt::UseMockKeychain(true);
    124 #endif
    125     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
    126     file_ = temp_dir_.path().AppendASCII("TestWebDatabase");
    127 
    128     table_.reset(new AutofillTable("en-US"));
    129     db_.reset(new WebDatabase);
    130     db_->AddTable(table_.get());
    131     ASSERT_EQ(sql::INIT_OK, db_->Init(file_));
    132   }
    133 
    134   base::FilePath file_;
    135   base::ScopedTempDir temp_dir_;
    136   scoped_ptr<AutofillTable> table_;
    137   scoped_ptr<WebDatabase> db_;
    138 
    139  private:
    140   DISALLOW_COPY_AND_ASSIGN(AutofillTableTest);
    141 };
    142 
    143 TEST_F(AutofillTableTest, Autofill) {
    144   Time t1 = Time::Now();
    145 
    146   // Simulate the submission of a handful of entries in a field called "Name",
    147   // some more often than others.
    148   AutofillChangeList changes;
    149   FormFieldData field;
    150   field.name = ASCIIToUTF16("Name");
    151   field.value = ASCIIToUTF16("Superman");
    152   base::Time now = base::Time::Now();
    153   base::TimeDelta two_seconds = base::TimeDelta::FromSeconds(2);
    154   EXPECT_FALSE(table_->HasFormElements());
    155   EXPECT_TRUE(table_->AddFormFieldValue(field, &changes));
    156   EXPECT_TRUE(table_->HasFormElements());
    157   std::vector<base::string16> v;
    158   for (int i = 0; i < 5; ++i) {
    159     field.value = ASCIIToUTF16("Clark Kent");
    160     EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    161                                               now + i * two_seconds));
    162   }
    163   for (int i = 0; i < 3; ++i) {
    164     field.value = ASCIIToUTF16("Clark Sutter");
    165     EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    166                                               now + i * two_seconds));
    167   }
    168   for (int i = 0; i < 2; ++i) {
    169     field.name = ASCIIToUTF16("Favorite Color");
    170     field.value = ASCIIToUTF16("Green");
    171     EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    172                                               now + i * two_seconds));
    173   }
    174 
    175   // We have added the name Clark Kent 5 times, so count should be 5.
    176   EXPECT_EQ(5, GetAutofillEntryCount(ASCIIToUTF16("Name"),
    177                                      ASCIIToUTF16("Clark Kent"), db_.get()));
    178 
    179   // Storing in the data base should be case sensitive, so there should be no
    180   // database entry for clark kent lowercase.
    181   EXPECT_EQ(0, GetAutofillEntryCount(ASCIIToUTF16("Name"),
    182                                      ASCIIToUTF16("clark kent"), db_.get()));
    183 
    184   EXPECT_EQ(2, GetAutofillEntryCount(ASCIIToUTF16("Favorite Color"),
    185                                      ASCIIToUTF16("Green"), db_.get()));
    186 
    187   // This is meant to get a list of suggestions for Name.  The empty prefix
    188   // in the second argument means it should return all suggestions for a name
    189   // no matter what they start with.  The order that the names occur in the list
    190   // should be decreasing order by count.
    191   EXPECT_TRUE(table_->GetFormValuesForElementName(
    192       ASCIIToUTF16("Name"), base::string16(), &v, 6));
    193   EXPECT_EQ(3U, v.size());
    194   if (v.size() == 3) {
    195     EXPECT_EQ(ASCIIToUTF16("Clark Kent"), v[0]);
    196     EXPECT_EQ(ASCIIToUTF16("Clark Sutter"), v[1]);
    197     EXPECT_EQ(ASCIIToUTF16("Superman"), v[2]);
    198   }
    199 
    200   // If we query again limiting the list size to 1, we should only get the most
    201   // frequent entry.
    202   EXPECT_TRUE(table_->GetFormValuesForElementName(
    203       ASCIIToUTF16("Name"), base::string16(), &v, 1));
    204   EXPECT_EQ(1U, v.size());
    205   if (v.size() == 1) {
    206     EXPECT_EQ(ASCIIToUTF16("Clark Kent"), v[0]);
    207   }
    208 
    209   // Querying for suggestions given a prefix is case-insensitive, so the prefix
    210   // "cLa" shoud get suggestions for both Clarks.
    211   EXPECT_TRUE(table_->GetFormValuesForElementName(
    212       ASCIIToUTF16("Name"), ASCIIToUTF16("cLa"), &v, 6));
    213   EXPECT_EQ(2U, v.size());
    214   if (v.size() == 2) {
    215     EXPECT_EQ(ASCIIToUTF16("Clark Kent"), v[0]);
    216     EXPECT_EQ(ASCIIToUTF16("Clark Sutter"), v[1]);
    217   }
    218 
    219   // Removing all elements since the beginning of this function should remove
    220   // everything from the database.
    221   changes.clear();
    222   EXPECT_TRUE(table_->RemoveFormElementsAddedBetween(t1, Time(), &changes));
    223 
    224   const AutofillChange kExpectedChanges[] = {
    225     AutofillChange(AutofillChange::REMOVE,
    226                    AutofillKey(ASCIIToUTF16("Name"),
    227                                ASCIIToUTF16("Superman"))),
    228     AutofillChange(AutofillChange::REMOVE,
    229                    AutofillKey(ASCIIToUTF16("Name"),
    230                                ASCIIToUTF16("Clark Kent"))),
    231     AutofillChange(AutofillChange::REMOVE,
    232                    AutofillKey(ASCIIToUTF16("Name"),
    233                                ASCIIToUTF16("Clark Sutter"))),
    234     AutofillChange(AutofillChange::REMOVE,
    235                    AutofillKey(ASCIIToUTF16("Favorite Color"),
    236                                ASCIIToUTF16("Green"))),
    237   };
    238   EXPECT_EQ(arraysize(kExpectedChanges), changes.size());
    239   for (size_t i = 0; i < arraysize(kExpectedChanges); ++i) {
    240     EXPECT_EQ(kExpectedChanges[i], changes[i]);
    241   }
    242 
    243   EXPECT_EQ(0, GetAutofillEntryCount(ASCIIToUTF16("Name"),
    244                                      ASCIIToUTF16("Clark Kent"), db_.get()));
    245 
    246   EXPECT_TRUE(table_->GetFormValuesForElementName(
    247       ASCIIToUTF16("Name"), base::string16(), &v, 6));
    248   EXPECT_EQ(0U, v.size());
    249 
    250   // Now add some values with empty strings.
    251   const base::string16 kValue = ASCIIToUTF16("  toto   ");
    252   field.name = ASCIIToUTF16("blank");
    253   field.value = base::string16();
    254   EXPECT_TRUE(table_->AddFormFieldValue(field, &changes));
    255   field.name = ASCIIToUTF16("blank");
    256   field.value = ASCIIToUTF16(" ");
    257   EXPECT_TRUE(table_->AddFormFieldValue(field, &changes));
    258   field.name = ASCIIToUTF16("blank");
    259   field.value = ASCIIToUTF16("      ");
    260   EXPECT_TRUE(table_->AddFormFieldValue(field, &changes));
    261   field.name = ASCIIToUTF16("blank");
    262   field.value = kValue;
    263   EXPECT_TRUE(table_->AddFormFieldValue(field, &changes));
    264 
    265   // They should be stored normally as the DB layer does not check for empty
    266   // values.
    267   v.clear();
    268   EXPECT_TRUE(table_->GetFormValuesForElementName(
    269       ASCIIToUTF16("blank"), base::string16(), &v, 10));
    270   EXPECT_EQ(4U, v.size());
    271 }
    272 
    273 TEST_F(AutofillTableTest, Autofill_RemoveBetweenChanges) {
    274   TimeDelta one_day(TimeDelta::FromDays(1));
    275   Time t1 = Time::Now();
    276   Time t2 = t1 + one_day;
    277 
    278   AutofillChangeList changes;
    279   FormFieldData field;
    280   field.name = ASCIIToUTF16("Name");
    281   field.value = ASCIIToUTF16("Superman");
    282   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes, t1));
    283   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes, t2));
    284 
    285   changes.clear();
    286   EXPECT_TRUE(table_->RemoveFormElementsAddedBetween(t1, t2, &changes));
    287   ASSERT_EQ(1U, changes.size());
    288   EXPECT_EQ(AutofillChange(AutofillChange::UPDATE,
    289                            AutofillKey(ASCIIToUTF16("Name"),
    290                                        ASCIIToUTF16("Superman"))),
    291             changes[0]);
    292   changes.clear();
    293 
    294   EXPECT_TRUE(
    295       table_->RemoveFormElementsAddedBetween(t2, t2 + one_day, &changes));
    296   ASSERT_EQ(1U, changes.size());
    297   EXPECT_EQ(AutofillChange(AutofillChange::REMOVE,
    298                            AutofillKey(ASCIIToUTF16("Name"),
    299                                        ASCIIToUTF16("Superman"))),
    300             changes[0]);
    301 }
    302 
    303 TEST_F(AutofillTableTest, Autofill_AddChanges) {
    304   TimeDelta one_day(TimeDelta::FromDays(1));
    305   Time t1 = Time::Now();
    306   Time t2 = t1 + one_day;
    307 
    308   AutofillChangeList changes;
    309   FormFieldData field;
    310   field.name = ASCIIToUTF16("Name");
    311   field.value = ASCIIToUTF16("Superman");
    312   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes, t1));
    313   ASSERT_EQ(1U, changes.size());
    314   EXPECT_EQ(AutofillChange(AutofillChange::ADD,
    315                            AutofillKey(ASCIIToUTF16("Name"),
    316                                        ASCIIToUTF16("Superman"))),
    317             changes[0]);
    318 
    319   changes.clear();
    320   EXPECT_TRUE(
    321       table_->AddFormFieldValueTime(field, &changes, t2));
    322   ASSERT_EQ(1U, changes.size());
    323   EXPECT_EQ(AutofillChange(AutofillChange::UPDATE,
    324                            AutofillKey(ASCIIToUTF16("Name"),
    325                                        ASCIIToUTF16("Superman"))),
    326             changes[0]);
    327 }
    328 
    329 TEST_F(AutofillTableTest, Autofill_UpdateOneWithOneTimestamp) {
    330   AutofillEntry entry(MakeAutofillEntry("foo", "bar", 1, -1));
    331   std::vector<AutofillEntry> entries;
    332   entries.push_back(entry);
    333   ASSERT_TRUE(table_->UpdateAutofillEntries(entries));
    334 
    335   EXPECT_EQ(1, GetAutofillEntryCount(ASCIIToUTF16("foo"), ASCIIToUTF16("bar"),
    336                                      db_.get()));
    337 
    338   std::vector<AutofillEntry> all_entries;
    339   ASSERT_TRUE(table_->GetAllAutofillEntries(&all_entries));
    340   ASSERT_EQ(1U, all_entries.size());
    341   EXPECT_EQ(entry, all_entries[0]);
    342 }
    343 
    344 TEST_F(AutofillTableTest, Autofill_UpdateOneWithTwoTimestamps) {
    345   AutofillEntry entry(MakeAutofillEntry("foo", "bar", 1, 2));
    346   std::vector<AutofillEntry> entries;
    347   entries.push_back(entry);
    348   ASSERT_TRUE(table_->UpdateAutofillEntries(entries));
    349 
    350   EXPECT_EQ(2, GetAutofillEntryCount(ASCIIToUTF16("foo"), ASCIIToUTF16("bar"),
    351                                      db_.get()));
    352 
    353   std::vector<AutofillEntry> all_entries;
    354   ASSERT_TRUE(table_->GetAllAutofillEntries(&all_entries));
    355   ASSERT_EQ(1U, all_entries.size());
    356   EXPECT_EQ(entry, all_entries[0]);
    357 }
    358 
    359 TEST_F(AutofillTableTest, Autofill_GetAutofillTimestamps) {
    360   AutofillEntry entry(MakeAutofillEntry("foo", "bar", 1, 2));
    361   std::vector<AutofillEntry> entries;
    362   entries.push_back(entry);
    363   ASSERT_TRUE(table_->UpdateAutofillEntries(entries));
    364 
    365   Time date_created, date_last_used;
    366   ASSERT_TRUE(table_->GetAutofillTimestamps(ASCIIToUTF16("foo"),
    367                                             ASCIIToUTF16("bar"),
    368                                             &date_created,
    369                                             &date_last_used));
    370   EXPECT_EQ(Time::FromTimeT(1), date_created);
    371   EXPECT_EQ(Time::FromTimeT(2), date_last_used);
    372 }
    373 
    374 TEST_F(AutofillTableTest, Autofill_UpdateTwo) {
    375   AutofillEntry entry0(MakeAutofillEntry("foo", "bar0", 1, -1));
    376   AutofillEntry entry1(MakeAutofillEntry("foo", "bar1", 2, 3));
    377   std::vector<AutofillEntry> entries;
    378   entries.push_back(entry0);
    379   entries.push_back(entry1);
    380   ASSERT_TRUE(table_->UpdateAutofillEntries(entries));
    381 
    382   EXPECT_EQ(1, GetAutofillEntryCount(ASCIIToUTF16("foo"), ASCIIToUTF16("bar0"),
    383                                      db_.get()));
    384   EXPECT_EQ(2, GetAutofillEntryCount(ASCIIToUTF16("foo"), ASCIIToUTF16("bar1"),
    385                                      db_.get()));
    386 }
    387 
    388 TEST_F(AutofillTableTest, Autofill_UpdateReplace) {
    389   AutofillChangeList changes;
    390   // Add a form field.  This will be replaced.
    391   FormFieldData field;
    392   field.name = ASCIIToUTF16("Name");
    393   field.value = ASCIIToUTF16("Superman");
    394   EXPECT_TRUE(table_->AddFormFieldValue(field, &changes));
    395 
    396   AutofillEntry entry(MakeAutofillEntry("Name", "Superman", 1, 2));
    397   std::vector<AutofillEntry> entries;
    398   entries.push_back(entry);
    399   ASSERT_TRUE(table_->UpdateAutofillEntries(entries));
    400 
    401   std::vector<AutofillEntry> all_entries;
    402   ASSERT_TRUE(table_->GetAllAutofillEntries(&all_entries));
    403   ASSERT_EQ(1U, all_entries.size());
    404   EXPECT_EQ(entry, all_entries[0]);
    405 }
    406 
    407 TEST_F(AutofillTableTest, Autofill_UpdateDontReplace) {
    408   Time t = Time::Now();
    409   AutofillEntry existing(
    410       MakeAutofillEntry("Name", "Superman", t.ToTimeT(), -1));
    411 
    412   AutofillChangeList changes;
    413   // Add a form field.  This will NOT be replaced.
    414   FormFieldData field;
    415   field.name = existing.key().name();
    416   field.value = existing.key().value();
    417   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes, t));
    418   AutofillEntry entry(MakeAutofillEntry("Name", "Clark Kent", 1, 2));
    419   std::vector<AutofillEntry> entries;
    420   entries.push_back(entry);
    421   ASSERT_TRUE(table_->UpdateAutofillEntries(entries));
    422 
    423   std::vector<AutofillEntry> all_entries;
    424   ASSERT_TRUE(table_->GetAllAutofillEntries(&all_entries));
    425   ASSERT_EQ(2U, all_entries.size());
    426   AutofillEntrySet expected_entries(all_entries.begin(),
    427                                     all_entries.end(),
    428                                     CompareAutofillEntries);
    429   EXPECT_EQ(1U, expected_entries.count(existing));
    430   EXPECT_EQ(1U, expected_entries.count(entry));
    431 }
    432 
    433 TEST_F(AutofillTableTest, Autofill_AddFormFieldValues) {
    434   Time t = Time::Now();
    435 
    436   // Add multiple values for "firstname" and "lastname" names.  Test that only
    437   // first value of each gets added. Related to security issue:
    438   // http://crbug.com/51727.
    439   std::vector<FormFieldData> elements;
    440   FormFieldData field;
    441   field.name = ASCIIToUTF16("firstname");
    442   field.value = ASCIIToUTF16("Joe");
    443   elements.push_back(field);
    444 
    445   field.name = ASCIIToUTF16("firstname");
    446   field.value = ASCIIToUTF16("Jane");
    447   elements.push_back(field);
    448 
    449   field.name = ASCIIToUTF16("lastname");
    450   field.value = ASCIIToUTF16("Smith");
    451   elements.push_back(field);
    452 
    453   field.name = ASCIIToUTF16("lastname");
    454   field.value = ASCIIToUTF16("Jones");
    455   elements.push_back(field);
    456 
    457   std::vector<AutofillChange> changes;
    458   table_->AddFormFieldValuesTime(elements, &changes, t);
    459 
    460   ASSERT_EQ(2U, changes.size());
    461   EXPECT_EQ(changes[0], AutofillChange(AutofillChange::ADD,
    462                                        AutofillKey(ASCIIToUTF16("firstname"),
    463                                        ASCIIToUTF16("Joe"))));
    464   EXPECT_EQ(changes[1], AutofillChange(AutofillChange::ADD,
    465                                        AutofillKey(ASCIIToUTF16("lastname"),
    466                                        ASCIIToUTF16("Smith"))));
    467 
    468   std::vector<AutofillEntry> all_entries;
    469   ASSERT_TRUE(table_->GetAllAutofillEntries(&all_entries));
    470   ASSERT_EQ(2U, all_entries.size());
    471 }
    472 
    473 TEST_F(AutofillTableTest,
    474        Autofill_RemoveFormElementsAddedBetween_UsedOnlyBefore) {
    475   // Add an entry used only before the targetted range.
    476   AutofillChangeList changes;
    477   FormFieldData field;
    478   field.name = ASCIIToUTF16("Name");
    479   field.value = ASCIIToUTF16("Superman");
    480   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    481                                             base::Time::FromTimeT(10)));
    482   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    483                                             base::Time::FromTimeT(20)));
    484   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    485                                             base::Time::FromTimeT(30)));
    486   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    487                                             base::Time::FromTimeT(40)));
    488   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    489                                             base::Time::FromTimeT(50)));
    490 
    491   EXPECT_EQ(5, GetAutofillEntryCount(field.name, field.value, db_.get()));
    492 
    493   changes.clear();
    494   EXPECT_TRUE(table_->RemoveFormElementsAddedBetween(base::Time::FromTimeT(51),
    495                                                      base::Time::FromTimeT(60),
    496                                                      &changes));
    497   EXPECT_TRUE(changes.empty());
    498   EXPECT_EQ(5, GetAutofillEntryCount(field.name, field.value, db_.get()));
    499 }
    500 
    501 TEST_F(AutofillTableTest,
    502        Autofill_RemoveFormElementsAddedBetween_UsedOnlyAfter) {
    503   // Add an entry used only after the targetted range.
    504   AutofillChangeList changes;
    505   FormFieldData field;
    506   field.name = ASCIIToUTF16("Name");
    507   field.value = ASCIIToUTF16("Superman");
    508   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    509                                             base::Time::FromTimeT(50)));
    510   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    511                                             base::Time::FromTimeT(60)));
    512   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    513                                             base::Time::FromTimeT(70)));
    514   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    515                                             base::Time::FromTimeT(80)));
    516   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    517                                             base::Time::FromTimeT(90)));
    518 
    519   EXPECT_EQ(5, GetAutofillEntryCount(field.name, field.value, db_.get()));
    520 
    521   changes.clear();
    522   EXPECT_TRUE(table_->RemoveFormElementsAddedBetween(base::Time::FromTimeT(40),
    523                                                      base::Time::FromTimeT(50),
    524                                                      &changes));
    525   EXPECT_TRUE(changes.empty());
    526   EXPECT_EQ(5, GetAutofillEntryCount(field.name, field.value, db_.get()));
    527 }
    528 
    529 TEST_F(AutofillTableTest,
    530        Autofill_RemoveFormElementsAddedBetween_UsedOnlyDuring) {
    531   // Add an entry used entirely during the targetted range.
    532   AutofillChangeList changes;
    533   FormFieldData field;
    534   field.name = ASCIIToUTF16("Name");
    535   field.value = ASCIIToUTF16("Superman");
    536   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    537                                             base::Time::FromTimeT(10)));
    538   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    539                                             base::Time::FromTimeT(20)));
    540   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    541                                             base::Time::FromTimeT(30)));
    542   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    543                                             base::Time::FromTimeT(40)));
    544   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    545                                             base::Time::FromTimeT(50)));
    546 
    547   EXPECT_EQ(5, GetAutofillEntryCount(field.name, field.value, db_.get()));
    548 
    549   changes.clear();
    550   EXPECT_TRUE(table_->RemoveFormElementsAddedBetween(base::Time::FromTimeT(10),
    551                                                      base::Time::FromTimeT(51),
    552                                                      &changes));
    553   ASSERT_EQ(1U, changes.size());
    554   EXPECT_EQ(AutofillChange(AutofillChange::REMOVE,
    555                            AutofillKey(field.name, field.value)),
    556             changes[0]);
    557   EXPECT_EQ(0, GetAutofillEntryCount(field.name, field.value, db_.get()));
    558 }
    559 
    560 TEST_F(AutofillTableTest,
    561        Autofill_RemoveFormElementsAddedBetween_UsedBeforeAndDuring) {
    562   // Add an entry used both before and during the targetted range.
    563   AutofillChangeList changes;
    564   FormFieldData field;
    565   field.name = ASCIIToUTF16("Name");
    566   field.value = ASCIIToUTF16("Superman");
    567   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    568                                             base::Time::FromTimeT(10)));
    569   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    570                                             base::Time::FromTimeT(20)));
    571   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    572                                             base::Time::FromTimeT(30)));
    573   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    574                                             base::Time::FromTimeT(40)));
    575   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    576                                             base::Time::FromTimeT(50)));
    577 
    578   EXPECT_EQ(5, GetAutofillEntryCount(field.name, field.value, db_.get()));
    579 
    580   changes.clear();
    581   EXPECT_TRUE(table_->RemoveFormElementsAddedBetween(base::Time::FromTimeT(40),
    582                                                      base::Time::FromTimeT(60),
    583                                                      &changes));
    584   ASSERT_EQ(1U, changes.size());
    585   EXPECT_EQ(AutofillChange(AutofillChange::UPDATE,
    586                            AutofillKey(field.name, field.value)),
    587             changes[0]);
    588   EXPECT_EQ(4, GetAutofillEntryCount(field.name, field.value, db_.get()));
    589   base::Time date_created, date_last_used;
    590   EXPECT_TRUE(
    591       table_->GetAutofillTimestamps(field.name, field.value,
    592                                     &date_created, &date_last_used));
    593   EXPECT_EQ(base::Time::FromTimeT(10), date_created);
    594   EXPECT_EQ(base::Time::FromTimeT(39), date_last_used);
    595 }
    596 
    597 TEST_F(AutofillTableTest,
    598        Autofill_RemoveFormElementsAddedBetween_UsedDuringAndAfter) {
    599   // Add an entry used both during and after the targetted range.
    600   AutofillChangeList changes;
    601   FormFieldData field;
    602   field.name = ASCIIToUTF16("Name");
    603   field.value = ASCIIToUTF16("Superman");
    604   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    605                                             base::Time::FromTimeT(50)));
    606   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    607                                             base::Time::FromTimeT(60)));
    608   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    609                                             base::Time::FromTimeT(70)));
    610   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    611                                             base::Time::FromTimeT(80)));
    612   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
    613                                             base::Time::FromTimeT(90)));
    614 
    615   EXPECT_EQ(5, GetAutofillEntryCount(field.name, field.value, db_.get()));
    616 
    617   changes.clear();
    618   EXPECT_TRUE(table_->RemoveFormElementsAddedBetween(base::Time::FromTimeT(40),
    619                                                      base::Time::FromTimeT(80),
    620                                                      &changes));
    621   ASSERT_EQ(1U, changes.size());
    622   EXPECT_EQ(AutofillChange(AutofillChange::UPDATE,
    623                            AutofillKey(field.name, field.value)),
    624             changes[0]);
    625   EXPECT_EQ(2, GetAutofillEntryCount(field.name, field.value, db_.get()));
    626   base::Time date_created, date_last_used;
    627   EXPECT_TRUE(
    628       table_->GetAutofillTimestamps(field.name, field.value,
    629                                     &date_created, &date_last_used));
    630   EXPECT_EQ(base::Time::FromTimeT(80), date_created);
    631   EXPECT_EQ(base::Time::FromTimeT(90), date_last_used);
    632 }
    633 
    634 TEST_F(AutofillTableTest, AutofillProfile) {
    635   // Add a 'Home' profile.
    636   AutofillProfile home_profile;
    637   home_profile.set_origin(std::string());
    638   home_profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
    639   home_profile.SetRawInfo(NAME_MIDDLE, ASCIIToUTF16("Q."));
    640   home_profile.SetRawInfo(NAME_LAST, ASCIIToUTF16("Smith"));
    641   home_profile.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("js (at) smith.xyz"));
    642   home_profile.SetRawInfo(COMPANY_NAME, ASCIIToUTF16("Google"));
    643   home_profile.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("1234 Apple Way"));
    644   home_profile.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("unit 5"));
    645   home_profile.SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY,
    646                           ASCIIToUTF16("Beverly Hills"));
    647   home_profile.SetRawInfo(ADDRESS_HOME_CITY, ASCIIToUTF16("Los Angeles"));
    648   home_profile.SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("CA"));
    649   home_profile.SetRawInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("90025"));
    650   home_profile.SetRawInfo(ADDRESS_HOME_SORTING_CODE, ASCIIToUTF16("MAGIC ###"));
    651   home_profile.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
    652   home_profile.SetRawInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16("18181234567"));
    653   home_profile.set_language_code("en");
    654 
    655   Time pre_creation_time = Time::Now();
    656   EXPECT_TRUE(table_->AddAutofillProfile(home_profile));
    657   Time post_creation_time = Time::Now();
    658 
    659   // Get the 'Home' profile.
    660   AutofillProfile* db_profile;
    661   ASSERT_TRUE(table_->GetAutofillProfile(home_profile.guid(), &db_profile));
    662   EXPECT_EQ(home_profile, *db_profile);
    663   sql::Statement s_home(db_->GetSQLConnection()->GetUniqueStatement(
    664       "SELECT date_modified "
    665       "FROM autofill_profiles WHERE guid=?"));
    666   s_home.BindString(0, home_profile.guid());
    667   ASSERT_TRUE(s_home.is_valid());
    668   ASSERT_TRUE(s_home.Step());
    669   EXPECT_GE(s_home.ColumnInt64(0), pre_creation_time.ToTimeT());
    670   EXPECT_LE(s_home.ColumnInt64(0), post_creation_time.ToTimeT());
    671   EXPECT_FALSE(s_home.Step());
    672   delete db_profile;
    673 
    674   // Add a 'Billing' profile.
    675   AutofillProfile billing_profile = home_profile;
    676   billing_profile.set_guid(base::GenerateGUID());
    677   billing_profile.set_origin("https://www.example.com/");
    678   billing_profile.SetRawInfo(ADDRESS_HOME_LINE1,
    679                              ASCIIToUTF16("5678 Bottom Street"));
    680   billing_profile.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("suite 3"));
    681 
    682   pre_creation_time = Time::Now();
    683   EXPECT_TRUE(table_->AddAutofillProfile(billing_profile));
    684   post_creation_time = Time::Now();
    685 
    686   // Get the 'Billing' profile.
    687   ASSERT_TRUE(table_->GetAutofillProfile(billing_profile.guid(), &db_profile));
    688   EXPECT_EQ(billing_profile, *db_profile);
    689   sql::Statement s_billing(db_->GetSQLConnection()->GetUniqueStatement(
    690       "SELECT date_modified FROM autofill_profiles WHERE guid=?"));
    691   s_billing.BindString(0, billing_profile.guid());
    692   ASSERT_TRUE(s_billing.is_valid());
    693   ASSERT_TRUE(s_billing.Step());
    694   EXPECT_GE(s_billing.ColumnInt64(0), pre_creation_time.ToTimeT());
    695   EXPECT_LE(s_billing.ColumnInt64(0), post_creation_time.ToTimeT());
    696   EXPECT_FALSE(s_billing.Step());
    697   delete db_profile;
    698 
    699   // Update the 'Billing' profile, name only.
    700   billing_profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Jane"));
    701   Time pre_modification_time = Time::Now();
    702   EXPECT_TRUE(table_->UpdateAutofillProfile(billing_profile));
    703   Time post_modification_time = Time::Now();
    704   ASSERT_TRUE(table_->GetAutofillProfile(billing_profile.guid(), &db_profile));
    705   EXPECT_EQ(billing_profile, *db_profile);
    706   sql::Statement s_billing_updated(db_->GetSQLConnection()->GetUniqueStatement(
    707       "SELECT date_modified FROM autofill_profiles WHERE guid=?"));
    708   s_billing_updated.BindString(0, billing_profile.guid());
    709   ASSERT_TRUE(s_billing_updated.is_valid());
    710   ASSERT_TRUE(s_billing_updated.Step());
    711   EXPECT_GE(s_billing_updated.ColumnInt64(0),
    712             pre_modification_time.ToTimeT());
    713   EXPECT_LE(s_billing_updated.ColumnInt64(0),
    714             post_modification_time.ToTimeT());
    715   EXPECT_FALSE(s_billing_updated.Step());
    716   delete db_profile;
    717 
    718   // Update the 'Billing' profile.
    719   billing_profile.set_origin("Chrome settings");
    720   billing_profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Janice"));
    721   billing_profile.SetRawInfo(NAME_MIDDLE, ASCIIToUTF16("C."));
    722   billing_profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Joplin"));
    723   billing_profile.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("jane (at) singer.com"));
    724   billing_profile.SetRawInfo(COMPANY_NAME, ASCIIToUTF16("Indy"));
    725   billing_profile.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("Open Road"));
    726   billing_profile.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Route 66"));
    727   billing_profile.SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY,
    728                              ASCIIToUTF16("District 9"));
    729   billing_profile.SetRawInfo(ADDRESS_HOME_CITY, ASCIIToUTF16("NFA"));
    730   billing_profile.SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("NY"));
    731   billing_profile.SetRawInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("10011"));
    732   billing_profile.SetRawInfo(ADDRESS_HOME_SORTING_CODE, ASCIIToUTF16("123456"));
    733   billing_profile.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
    734   billing_profile.SetRawInfo(PHONE_HOME_WHOLE_NUMBER,
    735                              ASCIIToUTF16("18181230000"));
    736   Time pre_modification_time_2 = Time::Now();
    737   EXPECT_TRUE(table_->UpdateAutofillProfile(billing_profile));
    738   Time post_modification_time_2 = Time::Now();
    739   ASSERT_TRUE(table_->GetAutofillProfile(billing_profile.guid(), &db_profile));
    740   EXPECT_EQ(billing_profile, *db_profile);
    741   sql::Statement s_billing_updated_2(
    742       db_->GetSQLConnection()->GetUniqueStatement(
    743           "SELECT date_modified FROM autofill_profiles WHERE guid=?"));
    744   s_billing_updated_2.BindString(0, billing_profile.guid());
    745   ASSERT_TRUE(s_billing_updated_2.is_valid());
    746   ASSERT_TRUE(s_billing_updated_2.Step());
    747   EXPECT_GE(s_billing_updated_2.ColumnInt64(0),
    748             pre_modification_time_2.ToTimeT());
    749   EXPECT_LE(s_billing_updated_2.ColumnInt64(0),
    750             post_modification_time_2.ToTimeT());
    751   EXPECT_FALSE(s_billing_updated_2.Step());
    752   delete db_profile;
    753 
    754   // Remove the 'Billing' profile.
    755   EXPECT_TRUE(table_->RemoveAutofillProfile(billing_profile.guid()));
    756   EXPECT_FALSE(table_->GetAutofillProfile(billing_profile.guid(), &db_profile));
    757 }
    758 
    759 TEST_F(AutofillTableTest, AutofillProfileMultiValueNames) {
    760   AutofillProfile p;
    761   const base::string16 kJohnDoe(ASCIIToUTF16("John Doe"));
    762   const base::string16 kJohnPDoe(ASCIIToUTF16("John P. Doe"));
    763   std::vector<base::string16> set_values;
    764   set_values.push_back(kJohnDoe);
    765   set_values.push_back(kJohnPDoe);
    766   p.SetRawMultiInfo(NAME_FULL, set_values);
    767 
    768   EXPECT_TRUE(table_->AddAutofillProfile(p));
    769 
    770   AutofillProfile* db_profile;
    771   ASSERT_TRUE(table_->GetAutofillProfile(p.guid(), &db_profile));
    772   EXPECT_EQ(p, *db_profile);
    773   EXPECT_EQ(0, p.Compare(*db_profile));
    774   delete db_profile;
    775 
    776   // Update the values.
    777   const base::string16 kNoOne(ASCIIToUTF16("No One"));
    778   set_values[1] = kNoOne;
    779   p.SetRawMultiInfo(NAME_FULL, set_values);
    780   EXPECT_TRUE(table_->UpdateAutofillProfile(p));
    781   ASSERT_TRUE(table_->GetAutofillProfile(p.guid(), &db_profile));
    782   EXPECT_EQ(p, *db_profile);
    783   EXPECT_EQ(0, p.Compare(*db_profile));
    784   delete db_profile;
    785 
    786   // Delete values.
    787   set_values.clear();
    788   p.SetRawMultiInfo(NAME_FULL, set_values);
    789   EXPECT_TRUE(table_->UpdateAutofillProfile(p));
    790   ASSERT_TRUE(table_->GetAutofillProfile(p.guid(), &db_profile));
    791   EXPECT_EQ(p, *db_profile);
    792   EXPECT_EQ(0, p.Compare(*db_profile));
    793   EXPECT_EQ(base::string16(), db_profile->GetRawInfo(NAME_FULL));
    794   delete db_profile;
    795 }
    796 
    797 TEST_F(AutofillTableTest, AutofillProfileMultiValueEmails) {
    798   AutofillProfile p;
    799   const base::string16 kJohnDoe(ASCIIToUTF16("john (at) doe.com"));
    800   const base::string16 kJohnPDoe(ASCIIToUTF16("john_p (at) doe.com"));
    801   std::vector<base::string16> set_values;
    802   set_values.push_back(kJohnDoe);
    803   set_values.push_back(kJohnPDoe);
    804   p.SetRawMultiInfo(EMAIL_ADDRESS, set_values);
    805 
    806   EXPECT_TRUE(table_->AddAutofillProfile(p));
    807 
    808   AutofillProfile* db_profile;
    809   ASSERT_TRUE(table_->GetAutofillProfile(p.guid(), &db_profile));
    810   EXPECT_EQ(p, *db_profile);
    811   EXPECT_EQ(0, p.Compare(*db_profile));
    812   delete db_profile;
    813 
    814   // Update the values.
    815   const base::string16 kNoOne(ASCIIToUTF16("no (at) one.com"));
    816   set_values[1] = kNoOne;
    817   p.SetRawMultiInfo(EMAIL_ADDRESS, set_values);
    818   EXPECT_TRUE(table_->UpdateAutofillProfile(p));
    819   ASSERT_TRUE(table_->GetAutofillProfile(p.guid(), &db_profile));
    820   EXPECT_EQ(p, *db_profile);
    821   EXPECT_EQ(0, p.Compare(*db_profile));
    822   delete db_profile;
    823 
    824   // Delete values.
    825   set_values.clear();
    826   p.SetRawMultiInfo(EMAIL_ADDRESS, set_values);
    827   EXPECT_TRUE(table_->UpdateAutofillProfile(p));
    828   ASSERT_TRUE(table_->GetAutofillProfile(p.guid(), &db_profile));
    829   EXPECT_EQ(p, *db_profile);
    830   EXPECT_EQ(0, p.Compare(*db_profile));
    831   EXPECT_EQ(base::string16(), db_profile->GetRawInfo(EMAIL_ADDRESS));
    832   delete db_profile;
    833 }
    834 
    835 TEST_F(AutofillTableTest, AutofillProfileMultiValuePhone) {
    836   AutofillProfile p;
    837   const base::string16 kJohnDoe(ASCIIToUTF16("4151112222"));
    838   const base::string16 kJohnPDoe(ASCIIToUTF16("4151113333"));
    839   std::vector<base::string16> set_values;
    840   set_values.push_back(kJohnDoe);
    841   set_values.push_back(kJohnPDoe);
    842   p.SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, set_values);
    843 
    844   EXPECT_TRUE(table_->AddAutofillProfile(p));
    845 
    846   AutofillProfile* db_profile;
    847   ASSERT_TRUE(table_->GetAutofillProfile(p.guid(), &db_profile));
    848   EXPECT_EQ(p, *db_profile);
    849   EXPECT_EQ(0, p.Compare(*db_profile));
    850   delete db_profile;
    851 
    852   // Update the values.
    853   const base::string16 kNoOne(ASCIIToUTF16("4151110000"));
    854   set_values[1] = kNoOne;
    855   p.SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, set_values);
    856   EXPECT_TRUE(table_->UpdateAutofillProfile(p));
    857   ASSERT_TRUE(table_->GetAutofillProfile(p.guid(), &db_profile));
    858   EXPECT_EQ(p, *db_profile);
    859   EXPECT_EQ(0, p.Compare(*db_profile));
    860   delete db_profile;
    861 
    862   // Delete values.
    863   set_values.clear();
    864   p.SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, set_values);
    865   EXPECT_TRUE(table_->UpdateAutofillProfile(p));
    866   ASSERT_TRUE(table_->GetAutofillProfile(p.guid(), &db_profile));
    867   EXPECT_EQ(p, *db_profile);
    868   EXPECT_EQ(0, p.Compare(*db_profile));
    869   EXPECT_EQ(base::string16(), db_profile->GetRawInfo(EMAIL_ADDRESS));
    870   delete db_profile;
    871 }
    872 
    873 TEST_F(AutofillTableTest, AutofillProfileTrash) {
    874   std::vector<std::string> guids;
    875   table_->GetAutofillProfilesInTrash(&guids);
    876   EXPECT_TRUE(guids.empty());
    877 
    878   ASSERT_TRUE(table_->AddAutofillGUIDToTrash(
    879       "00000000-0000-0000-0000-000000000000"));
    880   ASSERT_TRUE(table_->AddAutofillGUIDToTrash(
    881       "00000000-0000-0000-0000-000000000001"));
    882   ASSERT_TRUE(table_->GetAutofillProfilesInTrash(&guids));
    883   EXPECT_EQ(2UL, guids.size());
    884   EXPECT_EQ("00000000-0000-0000-0000-000000000000", guids[0]);
    885   EXPECT_EQ("00000000-0000-0000-0000-000000000001", guids[1]);
    886 
    887   ASSERT_TRUE(table_->EmptyAutofillProfilesTrash());
    888   ASSERT_TRUE(table_->GetAutofillProfilesInTrash(&guids));
    889   EXPECT_TRUE(guids.empty());
    890 }
    891 
    892 TEST_F(AutofillTableTest, AutofillProfileTrashInteraction) {
    893   std::vector<std::string> guids;
    894   table_->GetAutofillProfilesInTrash(&guids);
    895   EXPECT_TRUE(guids.empty());
    896 
    897   AutofillProfile profile;
    898   profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
    899   profile.SetRawInfo(NAME_MIDDLE, ASCIIToUTF16("Q."));
    900   profile.SetRawInfo(NAME_LAST, ASCIIToUTF16("Smith"));
    901   profile.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("js (at) smith.xyz"));
    902   profile.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("1 Main St"));
    903   profile.SetRawInfo(ADDRESS_HOME_CITY, ASCIIToUTF16("Los Angeles"));
    904   profile.SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("CA"));
    905   profile.SetRawInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("90025"));
    906   profile.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
    907 
    908   // Mark this profile as in the trash.  This stops |AddAutofillProfile| from
    909   // adding it.
    910   EXPECT_TRUE(table_->AddAutofillGUIDToTrash(profile.guid()));
    911   EXPECT_TRUE(table_->AddAutofillProfile(profile));
    912   AutofillProfile* added_profile = NULL;
    913   EXPECT_FALSE(table_->GetAutofillProfile(profile.guid(), &added_profile));
    914   EXPECT_EQ(static_cast<AutofillProfile*>(NULL), added_profile);
    915 
    916   // Add the profile for real this time.
    917   EXPECT_TRUE(table_->EmptyAutofillProfilesTrash());
    918   EXPECT_TRUE(table_->GetAutofillProfilesInTrash(&guids));
    919   EXPECT_TRUE(guids.empty());
    920   EXPECT_TRUE(table_->AddAutofillProfile(profile));
    921   EXPECT_TRUE(table_->GetAutofillProfile(profile.guid(),
    922                                                         &added_profile));
    923   ASSERT_NE(static_cast<AutofillProfile*>(NULL), added_profile);
    924   delete added_profile;
    925 
    926   // Mark this profile as in the trash.  This stops |UpdateAutofillProfileMulti|
    927   // from updating it.  In normal operation a profile should not be both in the
    928   // trash and in the profiles table simultaneously.
    929   EXPECT_TRUE(table_->AddAutofillGUIDToTrash(profile.guid()));
    930   profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Jane"));
    931   EXPECT_TRUE(table_->UpdateAutofillProfile(profile));
    932   AutofillProfile* updated_profile = NULL;
    933   EXPECT_TRUE(table_->GetAutofillProfile(profile.guid(), &updated_profile));
    934   ASSERT_NE(static_cast<AutofillProfile*>(NULL), added_profile);
    935   EXPECT_EQ(ASCIIToUTF16("John"), updated_profile->GetRawInfo(NAME_FIRST));
    936   delete updated_profile;
    937 
    938   // Try to delete the trashed profile.  This stops |RemoveAutofillProfile| from
    939   // deleting it.  In normal operation deletion is done by migration step, and
    940   // removal from trash is done by |WebDataService|.  |RemoveAutofillProfile|
    941   // does remove the item from the trash if it is found however, so that if
    942   // other clients remove it (via Sync say) then it is gone and doesn't need to
    943   // be processed further by |WebDataService|.
    944   EXPECT_TRUE(table_->RemoveAutofillProfile(profile.guid()));
    945   AutofillProfile* removed_profile = NULL;
    946   EXPECT_TRUE(table_->GetAutofillProfile(profile.guid(), &removed_profile));
    947   EXPECT_FALSE(table_->IsAutofillGUIDInTrash(profile.guid()));
    948   ASSERT_NE(static_cast<AutofillProfile*>(NULL), removed_profile);
    949   delete removed_profile;
    950 
    951   // Check that emptying the trash now allows removal to occur.
    952   EXPECT_TRUE(table_->EmptyAutofillProfilesTrash());
    953   EXPECT_TRUE(table_->RemoveAutofillProfile(profile.guid()));
    954   removed_profile = NULL;
    955   EXPECT_FALSE(table_->GetAutofillProfile(profile.guid(), &removed_profile));
    956   EXPECT_EQ(static_cast<AutofillProfile*>(NULL), removed_profile);
    957 }
    958 
    959 TEST_F(AutofillTableTest, CreditCard) {
    960   // Add a 'Work' credit card.
    961   CreditCard work_creditcard;
    962   work_creditcard.set_origin("https://www.example.com/");
    963   work_creditcard.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Jack Torrance"));
    964   work_creditcard.SetRawInfo(CREDIT_CARD_NUMBER,
    965                              ASCIIToUTF16("1234567890123456"));
    966   work_creditcard.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("04"));
    967   work_creditcard.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR,
    968                              ASCIIToUTF16("2013"));
    969 
    970   Time pre_creation_time = Time::Now();
    971   EXPECT_TRUE(table_->AddCreditCard(work_creditcard));
    972   Time post_creation_time = Time::Now();
    973 
    974   // Get the 'Work' credit card.
    975   CreditCard* db_creditcard;
    976   ASSERT_TRUE(table_->GetCreditCard(work_creditcard.guid(), &db_creditcard));
    977   EXPECT_EQ(work_creditcard, *db_creditcard);
    978   sql::Statement s_work(db_->GetSQLConnection()->GetUniqueStatement(
    979       "SELECT guid, name_on_card, expiration_month, expiration_year, "
    980       "card_number_encrypted, date_modified "
    981       "FROM credit_cards WHERE guid=?"));
    982   s_work.BindString(0, work_creditcard.guid());
    983   ASSERT_TRUE(s_work.is_valid());
    984   ASSERT_TRUE(s_work.Step());
    985   EXPECT_GE(s_work.ColumnInt64(5), pre_creation_time.ToTimeT());
    986   EXPECT_LE(s_work.ColumnInt64(5), post_creation_time.ToTimeT());
    987   EXPECT_FALSE(s_work.Step());
    988   delete db_creditcard;
    989 
    990   // Add a 'Target' credit card.
    991   CreditCard target_creditcard;
    992   target_creditcard.set_origin(std::string());
    993   target_creditcard.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Jack Torrance"));
    994   target_creditcard.SetRawInfo(CREDIT_CARD_NUMBER,
    995                                ASCIIToUTF16("1111222233334444"));
    996   target_creditcard.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("06"));
    997   target_creditcard.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR,
    998                                ASCIIToUTF16("2012"));
    999 
   1000   pre_creation_time = Time::Now();
   1001   EXPECT_TRUE(table_->AddCreditCard(target_creditcard));
   1002   post_creation_time = Time::Now();
   1003   ASSERT_TRUE(table_->GetCreditCard(target_creditcard.guid(), &db_creditcard));
   1004   EXPECT_EQ(target_creditcard, *db_creditcard);
   1005   sql::Statement s_target(db_->GetSQLConnection()->GetUniqueStatement(
   1006       "SELECT guid, name_on_card, expiration_month, expiration_year, "
   1007       "card_number_encrypted, date_modified "
   1008       "FROM credit_cards WHERE guid=?"));
   1009   s_target.BindString(0, target_creditcard.guid());
   1010   ASSERT_TRUE(s_target.is_valid());
   1011   ASSERT_TRUE(s_target.Step());
   1012   EXPECT_GE(s_target.ColumnInt64(5), pre_creation_time.ToTimeT());
   1013   EXPECT_LE(s_target.ColumnInt64(5), post_creation_time.ToTimeT());
   1014   EXPECT_FALSE(s_target.Step());
   1015   delete db_creditcard;
   1016 
   1017   // Update the 'Target' credit card.
   1018   target_creditcard.set_origin("Interactive Autofill dialog");
   1019   target_creditcard.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Charles Grady"));
   1020   Time pre_modification_time = Time::Now();
   1021   EXPECT_TRUE(table_->UpdateCreditCard(target_creditcard));
   1022   Time post_modification_time = Time::Now();
   1023   ASSERT_TRUE(table_->GetCreditCard(target_creditcard.guid(), &db_creditcard));
   1024   EXPECT_EQ(target_creditcard, *db_creditcard);
   1025   sql::Statement s_target_updated(db_->GetSQLConnection()->GetUniqueStatement(
   1026       "SELECT guid, name_on_card, expiration_month, expiration_year, "
   1027       "card_number_encrypted, date_modified "
   1028       "FROM credit_cards WHERE guid=?"));
   1029   s_target_updated.BindString(0, target_creditcard.guid());
   1030   ASSERT_TRUE(s_target_updated.is_valid());
   1031   ASSERT_TRUE(s_target_updated.Step());
   1032   EXPECT_GE(s_target_updated.ColumnInt64(5), pre_modification_time.ToTimeT());
   1033   EXPECT_LE(s_target_updated.ColumnInt64(5), post_modification_time.ToTimeT());
   1034   EXPECT_FALSE(s_target_updated.Step());
   1035   delete db_creditcard;
   1036 
   1037   // Remove the 'Target' credit card.
   1038   EXPECT_TRUE(table_->RemoveCreditCard(target_creditcard.guid()));
   1039   EXPECT_FALSE(table_->GetCreditCard(target_creditcard.guid(), &db_creditcard));
   1040 }
   1041 
   1042 TEST_F(AutofillTableTest, UpdateAutofillProfile) {
   1043   // Add a profile to the db.
   1044   AutofillProfile profile;
   1045   profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
   1046   profile.SetRawInfo(NAME_MIDDLE, ASCIIToUTF16("Q."));
   1047   profile.SetRawInfo(NAME_LAST, ASCIIToUTF16("Smith"));
   1048   profile.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("js (at) example.com"));
   1049   profile.SetRawInfo(COMPANY_NAME, ASCIIToUTF16("Google"));
   1050   profile.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("1234 Apple Way"));
   1051   profile.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("unit 5"));
   1052   profile.SetRawInfo(ADDRESS_HOME_CITY, ASCIIToUTF16("Los Angeles"));
   1053   profile.SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("CA"));
   1054   profile.SetRawInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("90025"));
   1055   profile.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
   1056   profile.SetRawInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16("18181234567"));
   1057   profile.set_language_code("en");
   1058   table_->AddAutofillProfile(profile);
   1059 
   1060   // Set a mocked value for the profile's creation time.
   1061   const time_t kMockCreationDate = Time::Now().ToTimeT() - 13;
   1062   sql::Statement s_mock_creation_date(
   1063       db_->GetSQLConnection()->GetUniqueStatement(
   1064           "UPDATE autofill_profiles SET date_modified = ?"));
   1065   ASSERT_TRUE(s_mock_creation_date.is_valid());
   1066   s_mock_creation_date.BindInt64(0, kMockCreationDate);
   1067   ASSERT_TRUE(s_mock_creation_date.Run());
   1068 
   1069   // Get the profile.
   1070   AutofillProfile* tmp_profile;
   1071   ASSERT_TRUE(table_->GetAutofillProfile(profile.guid(), &tmp_profile));
   1072   scoped_ptr<AutofillProfile> db_profile(tmp_profile);
   1073   EXPECT_EQ(profile, *db_profile);
   1074   sql::Statement s_original(db_->GetSQLConnection()->GetUniqueStatement(
   1075       "SELECT date_modified FROM autofill_profiles"));
   1076   ASSERT_TRUE(s_original.is_valid());
   1077   ASSERT_TRUE(s_original.Step());
   1078   EXPECT_EQ(kMockCreationDate, s_original.ColumnInt64(0));
   1079   EXPECT_FALSE(s_original.Step());
   1080 
   1081   // Now, update the profile and save the update to the database.
   1082   // The modification date should change to reflect the update.
   1083   profile.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("js (at) smith.xyz"));
   1084   table_->UpdateAutofillProfile(profile);
   1085 
   1086   // Get the profile.
   1087   ASSERT_TRUE(table_->GetAutofillProfile(profile.guid(), &tmp_profile));
   1088   db_profile.reset(tmp_profile);
   1089   EXPECT_EQ(profile, *db_profile);
   1090   sql::Statement s_updated(db_->GetSQLConnection()->GetUniqueStatement(
   1091       "SELECT date_modified FROM autofill_profiles"));
   1092   ASSERT_TRUE(s_updated.is_valid());
   1093   ASSERT_TRUE(s_updated.Step());
   1094   EXPECT_LT(kMockCreationDate, s_updated.ColumnInt64(0));
   1095   EXPECT_FALSE(s_updated.Step());
   1096 
   1097   // Set a mocked value for the profile's modification time.
   1098   const time_t mock_modification_date = Time::Now().ToTimeT() - 7;
   1099   sql::Statement s_mock_modification_date(
   1100       db_->GetSQLConnection()->GetUniqueStatement(
   1101           "UPDATE autofill_profiles SET date_modified = ?"));
   1102   ASSERT_TRUE(s_mock_modification_date.is_valid());
   1103   s_mock_modification_date.BindInt64(0, mock_modification_date);
   1104   ASSERT_TRUE(s_mock_modification_date.Run());
   1105 
   1106   // Finally, call into |UpdateAutofillProfile()| without changing the
   1107   // profile.  The modification date should not change.
   1108   table_->UpdateAutofillProfile(profile);
   1109 
   1110   // Get the profile.
   1111   ASSERT_TRUE(table_->GetAutofillProfile(profile.guid(), &tmp_profile));
   1112   db_profile.reset(tmp_profile);
   1113   EXPECT_EQ(profile, *db_profile);
   1114   sql::Statement s_unchanged(db_->GetSQLConnection()->GetUniqueStatement(
   1115       "SELECT date_modified FROM autofill_profiles"));
   1116   ASSERT_TRUE(s_unchanged.is_valid());
   1117   ASSERT_TRUE(s_unchanged.Step());
   1118   EXPECT_EQ(mock_modification_date, s_unchanged.ColumnInt64(0));
   1119   EXPECT_FALSE(s_unchanged.Step());
   1120 }
   1121 
   1122 TEST_F(AutofillTableTest, UpdateCreditCard) {
   1123   // Add a credit card to the db.
   1124   CreditCard credit_card;
   1125   credit_card.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Jack Torrance"));
   1126   credit_card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("1234567890123456"));
   1127   credit_card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("04"));
   1128   credit_card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2013"));
   1129   table_->AddCreditCard(credit_card);
   1130 
   1131   // Set a mocked value for the credit card's creation time.
   1132   const time_t kMockCreationDate = Time::Now().ToTimeT() - 13;
   1133   sql::Statement s_mock_creation_date(
   1134       db_->GetSQLConnection()->GetUniqueStatement(
   1135           "UPDATE credit_cards SET date_modified = ?"));
   1136   ASSERT_TRUE(s_mock_creation_date.is_valid());
   1137   s_mock_creation_date.BindInt64(0, kMockCreationDate);
   1138   ASSERT_TRUE(s_mock_creation_date.Run());
   1139 
   1140   // Get the credit card.
   1141   CreditCard* tmp_credit_card;
   1142   ASSERT_TRUE(table_->GetCreditCard(credit_card.guid(), &tmp_credit_card));
   1143   scoped_ptr<CreditCard> db_credit_card(tmp_credit_card);
   1144   EXPECT_EQ(credit_card, *db_credit_card);
   1145   sql::Statement s_original(db_->GetSQLConnection()->GetUniqueStatement(
   1146       "SELECT date_modified FROM credit_cards"));
   1147   ASSERT_TRUE(s_original.is_valid());
   1148   ASSERT_TRUE(s_original.Step());
   1149   EXPECT_EQ(kMockCreationDate, s_original.ColumnInt64(0));
   1150   EXPECT_FALSE(s_original.Step());
   1151 
   1152   // Now, update the credit card and save the update to the database.
   1153   // The modification date should change to reflect the update.
   1154   credit_card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("01"));
   1155   table_->UpdateCreditCard(credit_card);
   1156 
   1157   // Get the credit card.
   1158   ASSERT_TRUE(table_->GetCreditCard(credit_card.guid(), &tmp_credit_card));
   1159   db_credit_card.reset(tmp_credit_card);
   1160   EXPECT_EQ(credit_card, *db_credit_card);
   1161   sql::Statement s_updated(db_->GetSQLConnection()->GetUniqueStatement(
   1162       "SELECT date_modified FROM credit_cards"));
   1163   ASSERT_TRUE(s_updated.is_valid());
   1164   ASSERT_TRUE(s_updated.Step());
   1165   EXPECT_LT(kMockCreationDate, s_updated.ColumnInt64(0));
   1166   EXPECT_FALSE(s_updated.Step());
   1167 
   1168   // Set a mocked value for the credit card's modification time.
   1169   const time_t mock_modification_date = Time::Now().ToTimeT() - 7;
   1170   sql::Statement s_mock_modification_date(
   1171       db_->GetSQLConnection()->GetUniqueStatement(
   1172           "UPDATE credit_cards SET date_modified = ?"));
   1173   ASSERT_TRUE(s_mock_modification_date.is_valid());
   1174   s_mock_modification_date.BindInt64(0, mock_modification_date);
   1175   ASSERT_TRUE(s_mock_modification_date.Run());
   1176 
   1177   // Finally, call into |UpdateCreditCard()| without changing the credit card.
   1178   // The modification date should not change.
   1179   table_->UpdateCreditCard(credit_card);
   1180 
   1181   // Get the credit card.
   1182   ASSERT_TRUE(table_->GetCreditCard(credit_card.guid(), &tmp_credit_card));
   1183   db_credit_card.reset(tmp_credit_card);
   1184   EXPECT_EQ(credit_card, *db_credit_card);
   1185   sql::Statement s_unchanged(db_->GetSQLConnection()->GetUniqueStatement(
   1186       "SELECT date_modified FROM credit_cards"));
   1187   ASSERT_TRUE(s_unchanged.is_valid());
   1188   ASSERT_TRUE(s_unchanged.Step());
   1189   EXPECT_EQ(mock_modification_date, s_unchanged.ColumnInt64(0));
   1190   EXPECT_FALSE(s_unchanged.Step());
   1191 }
   1192 
   1193 TEST_F(AutofillTableTest, UpdateProfileOriginOnly) {
   1194   // Add a profile to the db.
   1195   AutofillProfile profile;
   1196   profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
   1197   profile.SetRawInfo(NAME_MIDDLE, ASCIIToUTF16("Q."));
   1198   profile.SetRawInfo(NAME_LAST, ASCIIToUTF16("Smith"));
   1199   profile.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("js (at) example.com"));
   1200   profile.SetRawInfo(COMPANY_NAME, ASCIIToUTF16("Google"));
   1201   profile.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("1234 Apple Way"));
   1202   profile.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("unit 5"));
   1203   profile.SetRawInfo(ADDRESS_HOME_CITY, ASCIIToUTF16("Los Angeles"));
   1204   profile.SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("CA"));
   1205   profile.SetRawInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("90025"));
   1206   profile.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
   1207   profile.SetRawInfo(PHONE_HOME_WHOLE_NUMBER, ASCIIToUTF16("18181234567"));
   1208   table_->AddAutofillProfile(profile);
   1209 
   1210   // Set a mocked value for the profile's creation time.
   1211   const time_t kMockCreationDate = Time::Now().ToTimeT() - 13;
   1212   sql::Statement s_mock_creation_date(
   1213       db_->GetSQLConnection()->GetUniqueStatement(
   1214           "UPDATE autofill_profiles SET date_modified = ?"));
   1215   ASSERT_TRUE(s_mock_creation_date.is_valid());
   1216   s_mock_creation_date.BindInt64(0, kMockCreationDate);
   1217   ASSERT_TRUE(s_mock_creation_date.Run());
   1218 
   1219   // Get the profile.
   1220   AutofillProfile* tmp_profile;
   1221   ASSERT_TRUE(table_->GetAutofillProfile(profile.guid(), &tmp_profile));
   1222   scoped_ptr<AutofillProfile> db_profile(tmp_profile);
   1223   EXPECT_EQ(profile, *db_profile);
   1224   sql::Statement s_original(db_->GetSQLConnection()->GetUniqueStatement(
   1225       "SELECT date_modified FROM autofill_profiles"));
   1226   ASSERT_TRUE(s_original.is_valid());
   1227   ASSERT_TRUE(s_original.Step());
   1228   EXPECT_EQ(kMockCreationDate, s_original.ColumnInt64(0));
   1229   EXPECT_FALSE(s_original.Step());
   1230 
   1231   // Now, update just the profile's origin and save the update to the database.
   1232   // The modification date should change to reflect the update.
   1233   profile.set_origin("https://www.example.com/");
   1234   table_->UpdateAutofillProfile(profile);
   1235 
   1236   // Get the profile.
   1237   ASSERT_TRUE(table_->GetAutofillProfile(profile.guid(), &tmp_profile));
   1238   db_profile.reset(tmp_profile);
   1239   EXPECT_EQ(profile, *db_profile);
   1240   sql::Statement s_updated(db_->GetSQLConnection()->GetUniqueStatement(
   1241       "SELECT date_modified FROM autofill_profiles"));
   1242   ASSERT_TRUE(s_updated.is_valid());
   1243   ASSERT_TRUE(s_updated.Step());
   1244   EXPECT_LT(kMockCreationDate, s_updated.ColumnInt64(0));
   1245   EXPECT_FALSE(s_updated.Step());
   1246 }
   1247 
   1248 TEST_F(AutofillTableTest, UpdateCreditCardOriginOnly) {
   1249   // Add a credit card to the db.
   1250   CreditCard credit_card;
   1251   credit_card.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Jack Torrance"));
   1252   credit_card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("1234567890123456"));
   1253   credit_card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("04"));
   1254   credit_card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2013"));
   1255   table_->AddCreditCard(credit_card);
   1256 
   1257   // Set a mocked value for the credit card's creation time.
   1258   const time_t kMockCreationDate = Time::Now().ToTimeT() - 13;
   1259   sql::Statement s_mock_creation_date(
   1260       db_->GetSQLConnection()->GetUniqueStatement(
   1261           "UPDATE credit_cards SET date_modified = ?"));
   1262   ASSERT_TRUE(s_mock_creation_date.is_valid());
   1263   s_mock_creation_date.BindInt64(0, kMockCreationDate);
   1264   ASSERT_TRUE(s_mock_creation_date.Run());
   1265 
   1266   // Get the credit card.
   1267   CreditCard* tmp_credit_card;
   1268   ASSERT_TRUE(table_->GetCreditCard(credit_card.guid(), &tmp_credit_card));
   1269   scoped_ptr<CreditCard> db_credit_card(tmp_credit_card);
   1270   EXPECT_EQ(credit_card, *db_credit_card);
   1271   sql::Statement s_original(db_->GetSQLConnection()->GetUniqueStatement(
   1272       "SELECT date_modified FROM credit_cards"));
   1273   ASSERT_TRUE(s_original.is_valid());
   1274   ASSERT_TRUE(s_original.Step());
   1275   EXPECT_EQ(kMockCreationDate, s_original.ColumnInt64(0));
   1276   EXPECT_FALSE(s_original.Step());
   1277 
   1278   // Now, update just the credit card's origin and save the update to the
   1279   // database.  The modification date should change to reflect the update.
   1280   credit_card.set_origin("https://www.example.com/");
   1281   table_->UpdateCreditCard(credit_card);
   1282 
   1283   // Get the credit card.
   1284   ASSERT_TRUE(table_->GetCreditCard(credit_card.guid(), &tmp_credit_card));
   1285   db_credit_card.reset(tmp_credit_card);
   1286   EXPECT_EQ(credit_card, *db_credit_card);
   1287   sql::Statement s_updated(db_->GetSQLConnection()->GetUniqueStatement(
   1288       "SELECT date_modified FROM credit_cards"));
   1289   ASSERT_TRUE(s_updated.is_valid());
   1290   ASSERT_TRUE(s_updated.Step());
   1291   EXPECT_LT(kMockCreationDate, s_updated.ColumnInt64(0));
   1292   EXPECT_FALSE(s_updated.Step());
   1293 }
   1294 
   1295 TEST_F(AutofillTableTest, RemoveAutofillDataModifiedBetween) {
   1296   // Populate the autofill_profiles and credit_cards tables.
   1297   ASSERT_TRUE(db_->GetSQLConnection()->Execute(
   1298       "INSERT INTO autofill_profiles (guid, date_modified) "
   1299       "VALUES('00000000-0000-0000-0000-000000000000', 11);"
   1300       "INSERT INTO autofill_profiles (guid, date_modified) "
   1301       "VALUES('00000000-0000-0000-0000-000000000001', 21);"
   1302       "INSERT INTO autofill_profiles (guid, date_modified) "
   1303       "VALUES('00000000-0000-0000-0000-000000000002', 31);"
   1304       "INSERT INTO autofill_profiles (guid, date_modified) "
   1305       "VALUES('00000000-0000-0000-0000-000000000003', 41);"
   1306       "INSERT INTO autofill_profiles (guid, date_modified) "
   1307       "VALUES('00000000-0000-0000-0000-000000000004', 51);"
   1308       "INSERT INTO autofill_profiles (guid, date_modified) "
   1309       "VALUES('00000000-0000-0000-0000-000000000005', 61);"
   1310       "INSERT INTO credit_cards (guid, date_modified) "
   1311       "VALUES('00000000-0000-0000-0000-000000000006', 17);"
   1312       "INSERT INTO credit_cards (guid, date_modified) "
   1313       "VALUES('00000000-0000-0000-0000-000000000007', 27);"
   1314       "INSERT INTO credit_cards (guid, date_modified) "
   1315       "VALUES('00000000-0000-0000-0000-000000000008', 37);"
   1316       "INSERT INTO credit_cards (guid, date_modified) "
   1317       "VALUES('00000000-0000-0000-0000-000000000009', 47);"
   1318       "INSERT INTO credit_cards (guid, date_modified) "
   1319       "VALUES('00000000-0000-0000-0000-000000000010', 57);"
   1320       "INSERT INTO credit_cards (guid, date_modified) "
   1321       "VALUES('00000000-0000-0000-0000-000000000011', 67);"));
   1322 
   1323   // Remove all entries modified in the bounded time range [17,41).
   1324   std::vector<std::string> profile_guids;
   1325   std::vector<std::string> credit_card_guids;
   1326   table_->RemoveAutofillDataModifiedBetween(
   1327       Time::FromTimeT(17), Time::FromTimeT(41),
   1328       &profile_guids, &credit_card_guids);
   1329   ASSERT_EQ(2UL, profile_guids.size());
   1330   EXPECT_EQ("00000000-0000-0000-0000-000000000001", profile_guids[0]);
   1331   EXPECT_EQ("00000000-0000-0000-0000-000000000002", profile_guids[1]);
   1332   sql::Statement s_autofill_profiles_bounded(
   1333       db_->GetSQLConnection()->GetUniqueStatement(
   1334           "SELECT date_modified FROM autofill_profiles"));
   1335   ASSERT_TRUE(s_autofill_profiles_bounded.is_valid());
   1336   ASSERT_TRUE(s_autofill_profiles_bounded.Step());
   1337   EXPECT_EQ(11, s_autofill_profiles_bounded.ColumnInt64(0));
   1338   ASSERT_TRUE(s_autofill_profiles_bounded.Step());
   1339   EXPECT_EQ(41, s_autofill_profiles_bounded.ColumnInt64(0));
   1340   ASSERT_TRUE(s_autofill_profiles_bounded.Step());
   1341   EXPECT_EQ(51, s_autofill_profiles_bounded.ColumnInt64(0));
   1342   ASSERT_TRUE(s_autofill_profiles_bounded.Step());
   1343   EXPECT_EQ(61, s_autofill_profiles_bounded.ColumnInt64(0));
   1344   EXPECT_FALSE(s_autofill_profiles_bounded.Step());
   1345   ASSERT_EQ(3UL, credit_card_guids.size());
   1346   EXPECT_EQ("00000000-0000-0000-0000-000000000006", credit_card_guids[0]);
   1347   EXPECT_EQ("00000000-0000-0000-0000-000000000007", credit_card_guids[1]);
   1348   EXPECT_EQ("00000000-0000-0000-0000-000000000008", credit_card_guids[2]);
   1349   sql::Statement s_credit_cards_bounded(
   1350       db_->GetSQLConnection()->GetUniqueStatement(
   1351           "SELECT date_modified FROM credit_cards"));
   1352   ASSERT_TRUE(s_credit_cards_bounded.is_valid());
   1353   ASSERT_TRUE(s_credit_cards_bounded.Step());
   1354   EXPECT_EQ(47, s_credit_cards_bounded.ColumnInt64(0));
   1355   ASSERT_TRUE(s_credit_cards_bounded.Step());
   1356   EXPECT_EQ(57, s_credit_cards_bounded.ColumnInt64(0));
   1357   ASSERT_TRUE(s_credit_cards_bounded.Step());
   1358   EXPECT_EQ(67, s_credit_cards_bounded.ColumnInt64(0));
   1359   EXPECT_FALSE(s_credit_cards_bounded.Step());
   1360 
   1361   // Remove all entries modified on or after time 51 (unbounded range).
   1362   table_->RemoveAutofillDataModifiedBetween(
   1363       Time::FromTimeT(51), Time(),
   1364       &profile_guids, &credit_card_guids);
   1365   ASSERT_EQ(2UL, profile_guids.size());
   1366   EXPECT_EQ("00000000-0000-0000-0000-000000000004", profile_guids[0]);
   1367   EXPECT_EQ("00000000-0000-0000-0000-000000000005", profile_guids[1]);
   1368   sql::Statement s_autofill_profiles_unbounded(
   1369       db_->GetSQLConnection()->GetUniqueStatement(
   1370           "SELECT date_modified FROM autofill_profiles"));
   1371   ASSERT_TRUE(s_autofill_profiles_unbounded.is_valid());
   1372   ASSERT_TRUE(s_autofill_profiles_unbounded.Step());
   1373   EXPECT_EQ(11, s_autofill_profiles_unbounded.ColumnInt64(0));
   1374   ASSERT_TRUE(s_autofill_profiles_unbounded.Step());
   1375   EXPECT_EQ(41, s_autofill_profiles_unbounded.ColumnInt64(0));
   1376   EXPECT_FALSE(s_autofill_profiles_unbounded.Step());
   1377   ASSERT_EQ(2UL, credit_card_guids.size());
   1378   EXPECT_EQ("00000000-0000-0000-0000-000000000010", credit_card_guids[0]);
   1379   EXPECT_EQ("00000000-0000-0000-0000-000000000011", credit_card_guids[1]);
   1380   sql::Statement s_credit_cards_unbounded(
   1381       db_->GetSQLConnection()->GetUniqueStatement(
   1382           "SELECT date_modified FROM credit_cards"));
   1383   ASSERT_TRUE(s_credit_cards_unbounded.is_valid());
   1384   ASSERT_TRUE(s_credit_cards_unbounded.Step());
   1385   EXPECT_EQ(47, s_credit_cards_unbounded.ColumnInt64(0));
   1386   EXPECT_FALSE(s_credit_cards_unbounded.Step());
   1387 
   1388   // Remove all remaining entries.
   1389   table_->RemoveAutofillDataModifiedBetween(
   1390       Time(), Time(),
   1391       &profile_guids, &credit_card_guids);
   1392   ASSERT_EQ(2UL, profile_guids.size());
   1393   EXPECT_EQ("00000000-0000-0000-0000-000000000000", profile_guids[0]);
   1394   EXPECT_EQ("00000000-0000-0000-0000-000000000003", profile_guids[1]);
   1395   sql::Statement s_autofill_profiles_empty(
   1396       db_->GetSQLConnection()->GetUniqueStatement(
   1397           "SELECT date_modified FROM autofill_profiles"));
   1398   ASSERT_TRUE(s_autofill_profiles_empty.is_valid());
   1399   EXPECT_FALSE(s_autofill_profiles_empty.Step());
   1400   ASSERT_EQ(1UL, credit_card_guids.size());
   1401   EXPECT_EQ("00000000-0000-0000-0000-000000000009", credit_card_guids[0]);
   1402   sql::Statement s_credit_cards_empty(
   1403       db_->GetSQLConnection()->GetUniqueStatement(
   1404           "SELECT date_modified FROM credit_cards"));
   1405   ASSERT_TRUE(s_credit_cards_empty.is_valid());
   1406   EXPECT_FALSE(s_credit_cards_empty.Step());
   1407 }
   1408 
   1409 TEST_F(AutofillTableTest, RemoveOriginURLsModifiedBetween) {
   1410   // Populate the autofill_profiles and credit_cards tables.
   1411   ASSERT_TRUE(db_->GetSQLConnection()->Execute(
   1412       "INSERT INTO autofill_profiles (guid, origin, date_modified) "
   1413       "VALUES('00000000-0000-0000-0000-000000000000', '', 11);"
   1414       "INSERT INTO autofill_profiles (guid, origin, date_modified) "
   1415       "VALUES('00000000-0000-0000-0000-000000000001', "
   1416       "       'https://www.example.com/', 21);"
   1417       "INSERT INTO autofill_profiles (guid, origin, date_modified) "
   1418       "VALUES('00000000-0000-0000-0000-000000000002', 'Chrome settings', 31);"
   1419       "INSERT INTO credit_cards (guid, origin, date_modified) "
   1420       "VALUES('00000000-0000-0000-0000-000000000003', '', 17);"
   1421       "INSERT INTO credit_cards (guid, origin, date_modified) "
   1422       "VALUES('00000000-0000-0000-0000-000000000004', "
   1423       "       'https://www.example.com/', 27);"
   1424       "INSERT INTO credit_cards (guid, origin, date_modified) "
   1425       "VALUES('00000000-0000-0000-0000-000000000005', 'Chrome settings', "
   1426       "       37);"));
   1427 
   1428   // Remove all origin URLs set in the bounded time range [21,27).
   1429   ScopedVector<AutofillProfile> profiles;
   1430   table_->RemoveOriginURLsModifiedBetween(
   1431       Time::FromTimeT(21), Time::FromTimeT(27), &profiles);
   1432   ASSERT_EQ(1UL, profiles.size());
   1433   EXPECT_EQ("00000000-0000-0000-0000-000000000001", profiles[0]->guid());
   1434   sql::Statement s_autofill_profiles_bounded(
   1435       db_->GetSQLConnection()->GetUniqueStatement(
   1436           "SELECT date_modified, origin FROM autofill_profiles"));
   1437   ASSERT_TRUE(s_autofill_profiles_bounded.is_valid());
   1438   ASSERT_TRUE(s_autofill_profiles_bounded.Step());
   1439   EXPECT_EQ(11, s_autofill_profiles_bounded.ColumnInt64(0));
   1440   EXPECT_EQ(std::string(), s_autofill_profiles_bounded.ColumnString(1));
   1441   ASSERT_TRUE(s_autofill_profiles_bounded.Step());
   1442   EXPECT_EQ(21, s_autofill_profiles_bounded.ColumnInt64(0));
   1443   EXPECT_EQ(std::string(), s_autofill_profiles_bounded.ColumnString(1));
   1444   ASSERT_TRUE(s_autofill_profiles_bounded.Step());
   1445   EXPECT_EQ(31, s_autofill_profiles_bounded.ColumnInt64(0));
   1446   EXPECT_EQ("Chrome settings", s_autofill_profiles_bounded.ColumnString(1));
   1447   sql::Statement s_credit_cards_bounded(
   1448       db_->GetSQLConnection()->GetUniqueStatement(
   1449           "SELECT date_modified, origin FROM credit_cards"));
   1450   ASSERT_TRUE(s_credit_cards_bounded.is_valid());
   1451   ASSERT_TRUE(s_credit_cards_bounded.Step());
   1452   EXPECT_EQ(17, s_credit_cards_bounded.ColumnInt64(0));
   1453   EXPECT_EQ(std::string(), s_credit_cards_bounded.ColumnString(1));
   1454   ASSERT_TRUE(s_credit_cards_bounded.Step());
   1455   EXPECT_EQ(27, s_credit_cards_bounded.ColumnInt64(0));
   1456   EXPECT_EQ("https://www.example.com/",
   1457             s_credit_cards_bounded.ColumnString(1));
   1458   ASSERT_TRUE(s_credit_cards_bounded.Step());
   1459   EXPECT_EQ(37, s_credit_cards_bounded.ColumnInt64(0));
   1460   EXPECT_EQ("Chrome settings", s_credit_cards_bounded.ColumnString(1));
   1461 
   1462   // Remove all origin URLS.
   1463   profiles.clear();
   1464   table_->RemoveOriginURLsModifiedBetween(Time(), Time(), &profiles);
   1465   EXPECT_EQ(0UL, profiles.size());
   1466   sql::Statement s_autofill_profiles_all(
   1467       db_->GetSQLConnection()->GetUniqueStatement(
   1468           "SELECT date_modified, origin FROM autofill_profiles"));
   1469   ASSERT_TRUE(s_autofill_profiles_all.is_valid());
   1470   ASSERT_TRUE(s_autofill_profiles_all.Step());
   1471   EXPECT_EQ(11, s_autofill_profiles_all.ColumnInt64(0));
   1472   EXPECT_EQ(std::string(), s_autofill_profiles_all.ColumnString(1));
   1473   ASSERT_TRUE(s_autofill_profiles_all.Step());
   1474   EXPECT_EQ(21, s_autofill_profiles_all.ColumnInt64(0));
   1475   EXPECT_EQ(std::string(), s_autofill_profiles_all.ColumnString(1));
   1476   ASSERT_TRUE(s_autofill_profiles_all.Step());
   1477   EXPECT_EQ(31, s_autofill_profiles_all.ColumnInt64(0));
   1478   EXPECT_EQ("Chrome settings", s_autofill_profiles_all.ColumnString(1));
   1479   sql::Statement s_credit_cards_all(
   1480       db_->GetSQLConnection()->GetUniqueStatement(
   1481           "SELECT date_modified, origin FROM credit_cards"));
   1482   ASSERT_TRUE(s_credit_cards_all.is_valid());
   1483   ASSERT_TRUE(s_credit_cards_all.Step());
   1484   EXPECT_EQ(17, s_credit_cards_all.ColumnInt64(0));
   1485   EXPECT_EQ(std::string(), s_credit_cards_all.ColumnString(1));
   1486   ASSERT_TRUE(s_credit_cards_all.Step());
   1487   EXPECT_EQ(27, s_credit_cards_all.ColumnInt64(0));
   1488   EXPECT_EQ(std::string(), s_credit_cards_all.ColumnString(1));
   1489   ASSERT_TRUE(s_credit_cards_all.Step());
   1490   EXPECT_EQ(37, s_credit_cards_all.ColumnInt64(0));
   1491   EXPECT_EQ("Chrome settings", s_credit_cards_all.ColumnString(1));
   1492 }
   1493 
   1494 TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_NoResults) {
   1495   std::vector<AutofillEntry> entries;
   1496   ASSERT_TRUE(table_->GetAllAutofillEntries(&entries));
   1497 
   1498   EXPECT_EQ(0U, entries.size());
   1499 }
   1500 
   1501 TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_OneResult) {
   1502   AutofillChangeList changes;
   1503   std::map<std::string, std::vector<Time> > name_value_times_map;
   1504 
   1505   time_t start = 0;
   1506   std::vector<Time> timestamps1;
   1507   FormFieldData field;
   1508   field.name = ASCIIToUTF16("Name");
   1509   field.value = ASCIIToUTF16("Superman");
   1510   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
   1511                                             Time::FromTimeT(start)));
   1512   timestamps1.push_back(Time::FromTimeT(start));
   1513   std::string key1("NameSuperman");
   1514   name_value_times_map.insert(
   1515       std::pair<std::string, std::vector<Time> >(key1, timestamps1));
   1516 
   1517   AutofillEntrySet expected_entries(CompareAutofillEntries);
   1518   AutofillKey ak1(ASCIIToUTF16("Name"), ASCIIToUTF16("Superman"));
   1519   AutofillEntry ae1(ak1, timestamps1.front(), timestamps1.back());
   1520 
   1521   expected_entries.insert(ae1);
   1522 
   1523   std::vector<AutofillEntry> entries;
   1524   ASSERT_TRUE(table_->GetAllAutofillEntries(&entries));
   1525   AutofillEntrySet entry_set(entries.begin(), entries.end(),
   1526                              CompareAutofillEntries);
   1527 
   1528   CompareAutofillEntrySets(entry_set, expected_entries);
   1529 }
   1530 
   1531 TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_TwoDistinct) {
   1532   AutofillChangeList changes;
   1533   std::map<std::string, std::vector<Time> > name_value_times_map;
   1534   time_t start = 0;
   1535 
   1536   std::vector<Time> timestamps1;
   1537   FormFieldData field;
   1538   field.name = ASCIIToUTF16("Name");
   1539   field.value = ASCIIToUTF16("Superman");
   1540   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
   1541                                             Time::FromTimeT(start)));
   1542   timestamps1.push_back(Time::FromTimeT(start));
   1543   std::string key1("NameSuperman");
   1544   name_value_times_map.insert(
   1545       std::pair<std::string, std::vector<Time> >(key1, timestamps1));
   1546 
   1547   ++start;
   1548   std::vector<Time> timestamps2;
   1549   field.name = ASCIIToUTF16("Name");
   1550   field.value = ASCIIToUTF16("Clark Kent");
   1551   EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
   1552                                             Time::FromTimeT(start)));
   1553   timestamps2.push_back(Time::FromTimeT(start));
   1554   std::string key2("NameClark Kent");
   1555   name_value_times_map.insert(
   1556       std::pair<std::string, std::vector<Time> >(key2, timestamps2));
   1557 
   1558   AutofillEntrySet expected_entries(CompareAutofillEntries);
   1559   AutofillKey ak1(ASCIIToUTF16("Name"), ASCIIToUTF16("Superman"));
   1560   AutofillKey ak2(ASCIIToUTF16("Name"), ASCIIToUTF16("Clark Kent"));
   1561   AutofillEntry ae1(ak1, timestamps1.front(), timestamps1.back());
   1562   AutofillEntry ae2(ak2, timestamps2.front(), timestamps2.back());
   1563 
   1564   expected_entries.insert(ae1);
   1565   expected_entries.insert(ae2);
   1566 
   1567   std::vector<AutofillEntry> entries;
   1568   ASSERT_TRUE(table_->GetAllAutofillEntries(&entries));
   1569   AutofillEntrySet entry_set(entries.begin(), entries.end(),
   1570                              CompareAutofillEntries);
   1571 
   1572   CompareAutofillEntrySets(entry_set, expected_entries);
   1573 }
   1574 
   1575 TEST_F(AutofillTableTest, Autofill_GetAllAutofillEntries_TwoSame) {
   1576   AutofillChangeList changes;
   1577   std::map<std::string, std::vector<Time> > name_value_times_map;
   1578 
   1579   std::vector<Time> timestamps;
   1580   time_t start = 0;
   1581   for (int i = 0; i < 2; ++i, ++start) {
   1582     FormFieldData field;
   1583     field.name = ASCIIToUTF16("Name");
   1584     field.value = ASCIIToUTF16("Superman");
   1585     EXPECT_TRUE(table_->AddFormFieldValueTime(field, &changes,
   1586                                               Time::FromTimeT(start)));
   1587     timestamps.push_back(Time::FromTimeT(start));
   1588   }
   1589 
   1590   std::string key("NameSuperman");
   1591   name_value_times_map.insert(
   1592       std::pair<std::string, std::vector<Time> >(key, timestamps));
   1593 
   1594   AutofillEntrySet expected_entries(CompareAutofillEntries);
   1595   AutofillKey ak1(ASCIIToUTF16("Name"), ASCIIToUTF16("Superman"));
   1596   AutofillEntry ae1(ak1, timestamps.front(), timestamps.back());
   1597 
   1598   expected_entries.insert(ae1);
   1599 
   1600   std::vector<AutofillEntry> entries;
   1601   ASSERT_TRUE(table_->GetAllAutofillEntries(&entries));
   1602   AutofillEntrySet entry_set(entries.begin(), entries.end(),
   1603                              CompareAutofillEntries);
   1604 
   1605   CompareAutofillEntrySets(entry_set, expected_entries);
   1606 }
   1607 
   1608 }  // namespace autofill
   1609