Return a list of changed from WebDatabase::RemoveFormElementsAddedBetween()

chrome/browser/webdata/web_database.cc

 // Copyright (c) 2009 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/web_database.h"
 
 #include <limits>
 
 #include "app/gfx/codec/png_codec.h"
 #include "app/l10n_util.h"
 #include "app/sql/statement.h"
 #include "app/sql/transaction.h"
+#include "base/tuple.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/diagnostics/sqlite_diagnostics.h"
 #include "chrome/browser/history/history_database.h"
+#include "chrome/browser/webdata/autofill_change.h"
 #include "webkit/glue/password_form.h"
 
 // Encryptor is the *wrong* way of doing things; we need to turn it into a
 // bottleneck to use the platform methods (e.g. Keychain on the Mac, Gnome
 // Keyring / KWallet on Linux). That's going to take a massive change in its
 // API... see:
 //   http://code.google.com/p/chromium/issues/detail?id=25404 (Linux)
 // but the (possibly-now-unused) Mac encryptor stub code needs to die too.
 #include "chrome/browser/password_manager/encryptor.h"
 
@@ skipping 83 matching lines @@
                         const std::vector<std::string>& strings) {
   if (strings.empty())
     return std::string();
   std::vector<std::string>::const_iterator i(strings.begin());
   std::string result(*i);
   while (++i != strings.end())
     result += separator + *i;
   return result;
 }
 
+namespace {
+typedef std::vector<Tuple3<int64, string16, string16> > AutofillElementList;
+}
+
 WebDatabase::WebDatabase() {
 }
 
 WebDatabase::~WebDatabase() {
 }
 
 void WebDatabase::BeginTransaction() {
   db_.BeginTransaction();
 }
 
@@ skipping 662 matching lines @@
 
   while (s.Step()) {
     PasswordForm* new_form = new PasswordForm();
     InitPasswordFormFromStatement(new_form, &s);
 
     forms->push_back(new_form);
   }
   return s.Succeeded();
 }
 
-bool WebDatabase::AddFormFieldValues(
-    const std::vector<FormField>& elements) {
+bool WebDatabase::AddFormFieldValues(const std::vector<FormField>& elements) {
+  return AddFormFieldValuesTime(elements, Time::Now());
+}
+
+bool WebDatabase::AddFormFieldValuesTime(const std::vector<FormField>& elements,
+                                         base::Time time) {
   bool result = true;
   for (std::vector<FormField>::const_iterator
        itr = elements.begin();
        itr != elements.end();
        itr++) {
-    result = result && AddFormFieldValue(*itr);
+    result = result && AddFormFieldValueTime(*itr, time);
   }
   return result;
 }
 
 bool WebDatabase::ClearAutofillEmptyValueElements() {
   sql::Statement s(db_.GetUniqueStatement(
       "SELECT pair_id FROM autofill WHERE TRIM(value)= \"\""));
   if (!s) {
     NOTREACHED() << "Statement prepare failed";
     return false;
@@ skipping 110 matching lines @@
   s.BindInt64(1, pair_id);
   if (!s.Run()) {
     NOTREACHED();
     return false;
   }
 
   return true;
 }
 
 bool WebDatabase::AddFormFieldValue(const FormField& element) {
+  return AddFormFieldValueTime(element, base::Time::Now());
+}
+
+bool WebDatabase::AddFormFieldValueTime(const FormField& element,
+                                        base::Time time) {
   int count = 0;
   int64 pair_id;
 
   if (!GetIDAndCountOfFormElement(element, &pair_id, &count))
     return false;
 
   if (count == 0 && !InsertFormElement(element, &pair_id))
     return false;
 
   return SetCountOfFormElement(pair_id, count + 1) &&
-      InsertPairIDAndDate(pair_id, Time::Now());
+      InsertPairIDAndDate(pair_id, time);
 }
 
 bool WebDatabase::GetFormValuesForElementName(const string16& name,
                                               const string16& prefix,
                                               std::vector<string16>* values,
                                               int limit) {
   DCHECK(values);
   sql::Statement s;
 
   if (prefix.empty()) {
@@ skipping 31 matching lines @@
     s.BindString(2, UTF16ToUTF8(next_prefix));
     s.BindInt(3, limit);
   }
 
   values->clear();
   while (s.Step())
     values->push_back(UTF8ToUTF16(s.ColumnString(0)));
   return s.Succeeded();
 }
 
-bool WebDatabase::RemoveFormElementsAddedBetween(base::Time delete_begin,
-                                                 base::Time delete_end) {
+bool WebDatabase::RemoveFormElementsAddedBetween(
+    base::Time delete_begin,
+    base::Time delete_end,
+    std::vector<AutofillChange>* changes) {
+  DCHECK(changes);
+  // Query for the pair_id, name, and value of all form elements that
+  // were used between the given times.
   sql::Statement s(db_.GetUniqueStatement(
-      "SELECT DISTINCT pair_id FROM autofill_dates "
-      "WHERE date_created >= ? AND date_created < ?"));
+      "SELECT DISTINCT a.pair_id, a.name, a.value "
+      "FROM autofill_dates ad JOIN autofill a ON ad.pair_id = a.pair_id "
+      "WHERE ad.date_created >= ? AND ad.date_created < ?"));
   if (!s) {
     NOTREACHED() << "Statement 1 prepare failed";
     return false;
   }
   s.BindInt64(0, delete_begin.ToTimeT());
   s.BindInt64(1,
               delete_end.is_null() ?
                   std::numeric_limits<int64>::max() :
                   delete_end.ToTimeT());
 
-  std::vector<int64> pair_ids;
+  AutofillElementList elements;
   while (s.Step())
-    pair_ids.push_back(s.ColumnInt64(0));
+    elements.push_back(MakeTuple(s.ColumnInt64(0),
+                                 UTF8ToUTF16(s.ColumnString(1)),
+                                 UTF8ToUTF16(s.ColumnString(2))));
 
   if (!s.Succeeded()) {
     NOTREACHED();
     return false;
   }
 
-  for (std::vector<int64>::iterator itr = pair_ids.begin();
-       itr != pair_ids.end();
+  for (AutofillElementList::iterator itr = elements.begin();
+       itr != elements.end();
        itr++) {
     int how_many = 0;
-    if (!RemoveFormElementForTimeRange(*itr, delete_begin, delete_end,
+    if (!RemoveFormElementForTimeRange(itr->a, delete_begin, delete_end,
                                        &how_many)) {
       return false;
     }
-    if (!AddToCountOfFormElement(*itr, -how_many))
+    bool was_removed = false;
+    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 WebDatabase::RemoveFormElementForTimeRange(int64 pair_id,
                                                 const Time delete_begin,
                                                 const Time delete_end,
                                                 int* how_many) {
   sql::Statement s(db_.GetUniqueStatement(
@@ skipping 25 matching lines @@
     return false;
   }
   s.BindString(0, UTF16ToUTF8(name));
   s.BindString(1, UTF16ToUTF8(value));
 
   if (s.Step())
     return RemoveFormElementForID(s.ColumnInt64(0));
   return false;
 }
 
-bool WebDatabase::AddToCountOfFormElement(int64 pair_id, int delta) {
+bool WebDatabase::AddToCountOfFormElement(int64 pair_id,
+                                          int delta,
+                                          bool* was_removed) {
+  DCHECK(was_removed);
   int count = 0;
+  *was_removed = false;
 
   if (!GetCountOfFormElement(pair_id, &count))
     return false;
 
   if (count + delta == 0) {
     if (!RemoveFormElementForID(pair_id))
       return false;
+    *was_removed = true;
   } else {
     if (!SetCountOfFormElement(pair_id, count + delta))
       return false;
   }
   return true;
 }
 
 bool WebDatabase::RemoveFormElementForID(int64 pair_id) {
   sql::Statement s(db_.GetUniqueStatement(
       "DELETE FROM autofill WHERE pair_id = ?"));
@@ skipping 47 matching lines @@
 
     // Add successive versions here.  Each should set the version number and
     // compatible version number as appropriate, then fall through to the next
     // case.
 
     case kCurrentVersionNumber:
       // No migration needed.
       return;
   }
 }