Cull autofill entries older than 60 days.

chrome/browser/webdata/autofill_table.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/webdata/autofill_table.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <set>
@@ skipping 407 matching lines @@
     return false;
 
   for (AutofillElementList::iterator itr = elements.begin();
        itr != elements.end(); itr++) {
     int how_many = 0;
     if (!RemoveFormElementForTimeRange(itr->a, delete_begin, delete_end,
                                        &how_many)) {
       return false;
     }
     bool was_removed = false;
-    if (!AddToCountOfFormElement(itr->a, -how_many, &was_removed))
-      return false;
+    if (how_many == 2) {
+      // We store at most 2 time stamps.
+      was_removed = true;
+      if (!RemoveFormElementForID(itr->a))
+        return false;
+    } else {
+      if (!AddToCountOfFormElement(itr->a, -how_many, &was_removed))
+        return false;
+    }
     AutofillChange::Type change_type =
         was_removed ? AutofillChange::REMOVE : AutofillChange::UPDATE;
     changes->push_back(AutofillChange(change_type,
                                       AutofillKey(itr->b, itr->c)));
   }
 
   return true;
 }
 
+bool AutofillTable::RemoveFormElementsAccessedBefore(
+    const base::Time& delete_end, std::vector<AutofillChange>* changes) {
+  DCHECK(changes);
+  DCHECK(!delete_end.is_null());
+  // Query for the pair_id, name, and value of all form elements that
+  // were used between the given times.
+  sql::Statement select_for_delete(db_->GetUniqueStatement(
+      "SELECT DISTINCT pair_id, name, value "
+      "FROM autofill WHERE pair_id NOT IN "
+      "(SELECT DISTINCT pair_id "
+      "FROM autofill_dates WHERE date_created >= ?)"));
+  select_for_delete.BindInt64(0, delete_end.ToTimeT());
+  AutofillElementList entries_to_delete;
+  while (select_for_delete.Step()) {
+    entries_to_delete.push_back(MakeTuple(select_for_delete.ColumnInt64(0),
+                                          select_for_delete.ColumnString16(1),
+                                          select_for_delete.ColumnString16(2)));
+  }
+  if (!select_for_delete.Succeeded())
+    return false;
+  sql::Statement delete_data_statement(db_->GetUniqueStatement(
+      "DELETE FROM autofill WHERE pair_id NOT IN ("
+      "SELECT pair_id FROM autofill_dates WHERE date_created >= ?)"));
+  delete_data_statement.BindInt64(0, delete_end.ToTimeT());
+  if (!delete_data_statement.Run())
+    return false;
+  sql::Statement delete_times_statement(db_->GetUniqueStatement(
+      "DELETE FROM autofill_dates WHERE pair_id NOT IN ("
+      "SELECT pair_id FROM autofill_dates WHERE date_created >= ?)"));
+  delete_times_statement.BindInt64(0, delete_end.ToTimeT());
+  if (!delete_times_statement.Run())
+    return false;
+
+  // Cull remaining entries.
+  std::vector<AutofillEntry> entries;
+  if (!GetAllAutofillEntries(&entries))
+    return false;
+  sql::Statement cull_date_entry(db_->GetUniqueStatement(
+      "DELETE FROM autofill_dates "
+      "WHERE pair_id == (SELECT pair_id FROM autofill "
+                         "WHERE name = ? and value = ?)"
+      "AND date_created != ? AND date_created != ?"));
+  for (size_t i = 0; i < entries.size(); ++i) {
+    cull_date_entry.BindString16(0, entries[i].key().name());
+    cull_date_entry.BindString16(1, entries[i].key().value());
+    cull_date_entry.BindInt64(2,
+        entries[i].timestamps().empty() ? 0 :
+        entries[i].timestamps().front().ToTimeT());
+    cull_date_entry.BindInt64(3,
+        entries[i].timestamps().empty() ? 0 :
+        entries[i].timestamps().back().ToTimeT());
+    if (!cull_date_entry.Run())
+      return false;
+    cull_date_entry.Reset();
+  }
+
+  changes->clear();
+  changes->reserve(entries_to_delete.size());
+
+  for (AutofillElementList::iterator it = entries_to_delete.begin();
+       it != entries_to_delete.end(); ++it) {
+    changes->push_back(AutofillChange(
+        AutofillChange::REMOVE, AutofillKey(it->b, it->c)));
+  }
+  return true;
+}
+
 bool AutofillTable::RemoveFormElementForTimeRange(int64 pair_id,
                                                   const Time& delete_begin,
                                                   const Time& delete_end,
                                                   int* how_many) {
   sql::Statement s(db_->GetUniqueStatement(
       "DELETE FROM autofill_dates WHERE pair_id = ? AND "
       "date_created >= ? AND date_created < ?"));
   s.BindInt64(0, pair_id);
   s.BindInt64(1, delete_begin.is_null() ? 0 : delete_begin.ToTimeT());
   s.BindInt64(2, delete_end.is_null() ? std::numeric_limits<int64>::max() :
@@ skipping 96 matching lines @@
                                         const Time& date_created) {
   sql::Statement s(db_->GetUniqueStatement(
       "INSERT INTO autofill_dates "
       "(pair_id, date_created) VALUES (?, ?)"));
   s.BindInt64(0, pair_id);
   s.BindInt64(1, date_created.ToTimeT());
 
   return s.Run();
 }
 
+bool AutofillTable::DeleteLastAccess(int64 pair_id) {
+  sql::Statement s(db_->GetUniqueStatement(
+      "DELETE FROM autofill_dates WHERE pair_id = ? and date_created IN "
+      "(SELECT date_created FROM autofill_dates WHERE pair_id = ? "
+      "ORDER BY date_created DESC LIMIT 1)"));

[Ilya Sherman, 2012/03/15 21:00:41]

The nested lookup is a little hard to follow.  Did you write it this way for
efficiency reasons?  If not, I'd prefer to first look up which data we should
delete, and then to delete it.

[GeorgeY, 2012/03/17 00:36:16]

Yes it is for efficiency reasons: doing two SQL statements slower than doing one
combined.
Added the comment.

+  s.BindInt64(0, pair_id);
+  s.BindInt64(1, pair_id);
+
+  return s.Run();
+}
+
 bool AutofillTable::AddFormFieldValuesTime(
     const std::vector<FormField>& elements,
     std::vector<AutofillChange>* changes,
     Time time) {
   // Only add one new entry for each unique element name.  Use |seen_names| to
   // track this.  Add up to |kMaximumUniqueNames| unique entries per form.
   const size_t kMaximumUniqueNames = 256;
   std::set<string16> seen_names;
   bool result = true;
   for (std::vector<FormField>::const_iterator
@@ skipping 161 matching lines @@
 
   if (!GetIDAndCountOfFormElement(element, &pair_id, &count))
     return false;
 
   if (count == 0 && !InsertFormElement(element, &pair_id))
     return false;
 
   if (!SetCountOfFormElement(pair_id, count + 1))
     return false;
 
+  // If we already have more than 2 times delete last one, before adding new
+  // one.

[Ilya Sherman, 2012/03/15 21:00:41]

nit: Perhaps we should overwrite it rather than deleting it?  (Not too important
if we're removing this table soon anyway.)

[GeorgeY, 2012/03/17 00:36:16]

I am not 100% certain that it will be more efficient - right now items are
ordered on the timestamps, so time queries require sequential access to the
file. (though I do not know how the indexing is implemented in SQLite - may be
sequential does not help much :))

+  if (count >= 2 && !DeleteLastAccess(pair_id))
+    return false;
+
   if (!InsertPairIDAndDate(pair_id, time))
     return false;
 
   AutofillChange::Type change_type =
       count == 0 ? AutofillChange::ADD : AutofillChange::UPDATE;
   changes->push_back(
       AutofillChange(change_type,
                      AutofillKey(element.name, element.value)));
   return true;
 }
@@ skipping 1127 matching lines @@
         "WHERE guid=?"));
     s_date.BindInt64(0, date_item->second);
     s_date.BindString(1, iter->guid());
 
     if (!s_date.Run())
       return false;
   }
 
   return true;
 }