Autofill database migration to clean up bogus profiles.

chrome/browser/webdata/web_database.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/webdata/web_database.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
 
 #include "app/sql/statement.h"
 #include "app/sql/transaction.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/tuple.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_country.h"
 #include "chrome/browser/autofill/autofill_profile.h"
 #include "chrome/browser/autofill/autofill_type.h"
 #include "chrome/browser/autofill/credit_card.h"
+#include "chrome/browser/autofill/personal_data_manager.h"
 #include "chrome/browser/diagnostics/sqlite_diagnostics.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/password_manager/encryptor.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/webdata/autofill_change.h"
 #include "chrome/common/guid.h"
 #include "content/common/notification_service.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/codec/png_codec.h"
@@ skipping 118 matching lines @@
 // autofill_profile_phones
 //                      This table contains the multi-valued phone fields
 //                      associated with a profile.
 //
 //   guid               The guid string that identifies the profile to which
 //                      the phone or fax number belongs.
 //   type               An integer constant designating either phone or fax type
 //                      of the number.
 //   number
 //
+// autofill_profiles_trash
+//                      This table contains guids of "trashed" autofill
+//                      profiles.  When a profile is removed its guid is added
+//                      to this table so that Sync can perform deferred removal.
+//
+//   guid               The guid string that identifies the profile to which
+//                      the phone or fax number belongs.

[Ilya Sherman, 2011/03/16 04:58:57]

nit: phone/fax is unrelated ;)

[dhollowa, 2011/03/16 16:13:35]

Done.

+//
 // credit_cards         This table contains credit card data added by the user
 //                      with the AutoFill dialog.  Most of the columns are
 //                      standard entries in a credit card form.
 //
 //   guid               A guid string to uniquely identify the profile.
 //                      Added in version 31.
 //   name_on_card
 //   expiration_month
 //   expiration_year
 //   card_number_encrypted Stores encrypted credit card number.
@@ skipping 14 matching lines @@
 
 using base::Time;
 
 namespace {
 
 typedef std::vector<Tuple3<int64, string16, string16> > AutofillElementList;
 
 // Current version number.  Note: when changing the current version number,
 // corresponding changes must happen in the unit tests, and new migration test
 // added.  See |WebDatabaseMigrationTest::kCurrentTestedVersionNumber|.
-const int kCurrentVersionNumber = 35;
-const int kCompatibleVersionNumber = 35;
+const int kCurrentVersionNumber = 36;
+const int kCompatibleVersionNumber = 36;
 
 // ID of the url column in keywords.
 const int kUrlIdPosition = 16;
 
 // Keys used in the meta table.
 const char* kDefaultSearchProviderKey = "Default Search Provider ID";
 const char* kBuiltinKeywordVersion = "Builtin Keyword Version";
 
 // The maximum length allowed for form data.
 const size_t kMaxDataLength = 1024;
@@ skipping 378 matching lines @@
       "DELETE FROM autofill_profile_phones WHERE guid = ?"));
   if (!s3) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
   s3.BindString(0, guid);
   return s3.Run();
 }
 
+// TODO(dhollowa): Find a common place for this.  It is duplicated in
+// personal_data_manager.cc.
+template<typename T>
+T* address_of(T& v) {
+  return &v;
+}
+
 }  // namespace
 
 WebDatabase::WebDatabase() {
 }
 
 WebDatabase::~WebDatabase() {
 }
 
 void WebDatabase::BeginTransaction() {
   db_.BeginTransaction();
@@ skipping 39 matching lines @@
   if (meta_table_.GetCompatibleVersionNumber() > kCurrentVersionNumber) {
     LOG(WARNING) << "Web database is too new.";
     return sql::INIT_TOO_NEW;
   }
 
   // Initialize the tables.
   if (!InitKeywordsTable() || !InitLoginsTable() || !InitWebAppIconsTable() ||
       !InitWebAppsTable() || !InitAutofillTable() ||
       !InitAutofillDatesTable() || !InitAutofillProfilesTable() ||
       !InitAutofillProfileNamesTable() || !InitAutofillProfileEmailsTable() ||
-      !InitAutofillProfilePhonesTable() || !InitCreditCardsTable() ||
-      !InitTokenServiceTable()) {
+      !InitAutofillProfilePhonesTable() || !InitAutofillProfileTrashTable() ||
+      !InitCreditCardsTable() || !InitTokenServiceTable()) {
     LOG(WARNING) << "Unable to initialize the web database.";
     return sql::INIT_FAILURE;
   }
 
   // If the file on disk is an older database version, bring it up to date.
   // If the migration fails we return an error to caller and do not commit
   // the migration.
   sql::InitStatus migration_status = MigrateOldVersionsAsNeeded();
   if (migration_status != sql::INIT_OK)
     return migration_status;
@@ skipping 324 matching lines @@
                      "guid VARCHAR, "
                      "type INTEGER DEFAULT 0, "
                      "number VARCHAR)")) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
+bool WebDatabase::InitAutofillProfileTrashTable() {
+  if (!db_.DoesTableExist("autofill_profiles_trash")) {
+    if (!db_.Execute("CREATE TABLE autofill_profiles_trash ( "
+                     "guid VARCHAR)")) {
+      NOTREACHED();
+      return false;
+    }
+  }
+  return true;
+}
+
 bool WebDatabase::InitCreditCardsTable() {
   if (!db_.DoesTableExist("credit_cards")) {
     if (!db_.Execute("CREATE TABLE credit_cards ( "
                      "guid VARCHAR PRIMARY KEY, "
                      "name_on_card VARCHAR, "
                      "expiration_month INTEGER, "
                      "expiration_year INTEGER, "
                      "card_number_encrypted BLOB, "
                      "date_modified INTEGER NOT NULL DEFAULT 0)")) {
       NOTREACHED();
@@ skipping 830 matching lines @@
   }
   s.BindString16(0, name);
   s.BindString16(1, value);
 
   if (s.Step())
     return RemoveFormElementForID(s.ColumnInt64(0));
   return false;
 }
 
 bool WebDatabase::AddAutofillProfile(const AutofillProfile& profile) {
+  if (IsAutofillGUIDInTrash(profile.guid()))
+    return true;
+
   sql::Statement s(db_.GetUniqueStatement(
       "INSERT INTO autofill_profiles"
       "(guid, company_name, address_line_1, address_line_2, city, state,"
       " zipcode, country, country_code, date_modified)"
       "VALUES (?,?,?,?,?,?,?,?,?,?)"));
   if (!s) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
@@ skipping 119 matching lines @@
       return false;
     profiles->push_back(profile);
   }
 
   return s.Succeeded();
 }
 
 bool WebDatabase::UpdateAutofillProfile(const AutofillProfile& profile) {
   DCHECK(guid::IsValidGUID(profile.guid()));
 
+  if (IsAutofillGUIDInTrash(profile.guid()))
+    return true;
+
   AutofillProfile* tmp_profile = NULL;
   if (!GetAutofillProfile(profile.guid(), &tmp_profile))
     return false;
 
   // Preserve appropriate modification dates by not updating unchanged profiles.
   scoped_ptr<AutofillProfile> old_profile(tmp_profile);
   if (*old_profile == profile)
     return true;
 
   sql::Statement s(db_.GetUniqueStatement(
@@ skipping 16 matching lines @@
 
   // Remove the old names, emails, and phone/fax numbers.
   if (!RemoveAutofillProfilePieces(profile.guid(), &db_))
     return false;
 
   return AddAutofillProfilePieces(profile.guid(), profile, &db_);
 }
 
 bool WebDatabase::RemoveAutofillProfile(const std::string& guid) {
   DCHECK(guid::IsValidGUID(guid));
+
+  if (IsAutofillGUIDInTrash(guid))
+    return true;

[Ilya Sherman, 2011/03/16 04:58:57]

Shouldn't we remove the profile from the trash here?

[dhollowa, 2011/03/16 16:13:35]

The trash is emptied by the WDS.  This should be sufficient and the semantics
are somewhat clearer this way, i.e.: a trashed item implies no-op for
add/update/remove.

However, it is conceivable that Sync sees an item deleted on another client that
is also "trashed" here.  In this case it is safer to clear that item from the
trash at this point.

+
   sql::Statement s(db_.GetUniqueStatement(
       "DELETE FROM autofill_profiles WHERE guid = ?"));
   if (!s) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
 
   s.BindString(0, guid);
   if (!s.Run())
     return false;
 
   return RemoveAutofillProfilePieces(guid, &db_);
 }
 
+bool WebDatabase::ClearAutofillProfiles() {
+  sql::Statement s1(db_.GetUniqueStatement(
+      "DELETE FROM autofill_profiles"));
+  if (!s1) {
+    NOTREACHED() << "Statement prepare failed";
+    return false;
+  }
+
+  if (!s1.Run())
+    return false;
+
+  sql::Statement s2(db_.GetUniqueStatement(
+      "DELETE FROM autofill_profile_names"));
+  if (!s2) {
+    NOTREACHED() << "Statement prepare failed";
+    return false;
+  }
+
+  if (!s2.Run())
+    return false;
+
+  sql::Statement s3(db_.GetUniqueStatement(
+      "DELETE FROM autofill_profile_emails"));
+  if (!s3) {
+    NOTREACHED() << "Statement prepare failed";
+    return false;
+  }
+
+  if (!s3.Run())
+    return false;
+
+  sql::Statement s4(db_.GetUniqueStatement(
+      "DELETE FROM autofill_profile_phones"));
+  if (!s4) {
+    NOTREACHED() << "Statement prepare failed";
+    return false;
+  }
+
+  if (!s4.Run())
+    return false;
+
+  return true;
+}
+
 bool WebDatabase::AddCreditCard(const CreditCard& credit_card) {
   sql::Statement s(db_.GetUniqueStatement(
       "INSERT INTO credit_cards"
       "(guid, name_on_card, expiration_month, expiration_year, "
       "card_number_encrypted, date_modified)"
       "VALUES (?,?,?,?,?,?)"));
   if (!s) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
@@ skipping 139 matching lines @@
   s_credit_cards.Run();
 
   if (!s_credit_cards.Succeeded()) {
     NOTREACHED();
     return false;
   }
 
   return true;
 }
 
+bool WebDatabase::GetAutofillProfilesInTrash(std::vector<std::string>* guids) {
+  guids->clear();
+
+  sql::Statement s(db_.GetUniqueStatement(
+      "SELECT guid "
+      "FROM autofill_profiles_trash"));
+  if (!s) {
+    NOTREACHED() << "Statement prepare failed";
+    return false;
+  }
+
+  while (s.Step()) {
+    std::string guid = s.ColumnString(0);
+    guids->push_back(guid);
+  }
+
+  return s.Succeeded();
+}
+
+bool WebDatabase::EmptyAutofillProfilesTrash() {
+  sql::Statement s(db_.GetUniqueStatement(
+      "DELETE FROM autofill_profiles_trash"));
+  if (!s) {
+    NOTREACHED() << "Statement prepare failed";
+    return false;
+  }
+
+  return s.Run();
+}
+
 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;
 
@@ skipping 16 matching lines @@
     return false;
   }
   s.BindInt64(0, pair_id);
   if (s.Run()) {
     return RemoveFormElementForTimeRange(pair_id, base::Time(), base::Time(),
                                          NULL);
   }
   return false;
 }
 
+bool WebDatabase::AddAutofillGUIDToTrash(const std::string& guid) {
+  sql::Statement s(db_.GetUniqueStatement(
+    "INSERT INTO autofill_profiles_trash"
+    " (guid) "
+    "VALUES (?)"));
+  if (!s) {
+    NOTREACHED();
+    return sql::INIT_FAILURE;
+  }
+
+  s.BindString(0, guid);
+  if (!s.Run()) {
+    NOTREACHED();
+    return false;
+  }
+  return true;
+}
+
+bool WebDatabase::IsAutofillGUIDInTrash(const std::string& guid) {
+  sql::Statement s(db_.GetUniqueStatement(
+      "SELECT guid "
+      "FROM autofill_profiles_trash "
+      "WHERE guid = ?"));
+  if (!s) {
+    NOTREACHED() << "Statement prepare failed";
+    return false;
+  }
+
+  s.BindString(0, guid);
+  return s.Step();
+}
+
 sql::InitStatus WebDatabase::MigrateOldVersionsAsNeeded(){
   // Migrate if necessary.
   int current_version = meta_table_.GetVersionNumber();
   switch (current_version) {
     // Versions 1 - 19 are unhandled.  Version numbers greater than
     // kCurrentVersionNumber should have already been weeded out by the caller.
     default:
       // When the version is too old, we return failure error code.  The schema
       // is too out of date to migrate.
       // There should not be a released product that makes a database too old to
@@ skipping 841 matching lines @@
           return sql::INIT_FAILURE;
         }
       }
 
       meta_table_.SetVersionNumber(35);
       meta_table_.SetCompatibleVersionNumber(
           std::min(35, kCompatibleVersionNumber));
 
       // FALL THROUGH
 
+    case 35:
+      // Merge and cull older profiles where possible.
+      {
+        sql::Statement s(db_.GetUniqueStatement(
+            "SELECT guid, date_modified "
+            "FROM autofill_profiles"));
+        if (!s) {
+          NOTREACHED() << "Statement prepare failed";
+          return sql::INIT_FAILURE;
+        }
+
+        // Accumulate the good profiles.
+        std::vector<AutofillProfile> accumulated_profiles;
+        std::vector<AutofillProfile*> accumulated_profiles_p;
+        std::map<std::string, int64> modification_map;
+        while (s.Step()) {
+          std::string guid = s.ColumnString(0);
+          int64 date_modified = s.ColumnInt64(1);
+          modification_map.insert(
+              std::pair<std::string, int64>(guid, date_modified));
+          AutofillProfile* profile = NULL;
+          if (!GetAutofillProfile(guid, &profile)) {
+            NOTREACHED() << "Bad read of profile.";
+            return sql::INIT_FAILURE;
+          }
+          scoped_ptr<AutofillProfile> p(profile);
+
+          if (PersonalDataManager::IsSuitableMergeProfile(*p)) {
+            std::vector<AutofillProfile> merged_profiles;
+            bool merged = PersonalDataManager::MergeProfile(
+                *p, accumulated_profiles_p, &merged_profiles);
+
+            std::swap(accumulated_profiles, merged_profiles);
+
+            accumulated_profiles_p.clear();
+            accumulated_profiles_p.resize(accumulated_profiles.size());
+            std::transform(accumulated_profiles.begin(),
+                           accumulated_profiles.end(),
+                           accumulated_profiles_p.begin(),
+                           address_of<AutofillProfile>);
+
+            // If the profile got merged trash the original.
+            if (merged)
+              AddAutofillGUIDToTrash(p->guid());
+          } else {
+            // An invalid profile, so trash it.
+            AddAutofillGUIDToTrash(p->guid());
+          }
+        }
+
+        // Drop the current profiles.
+        if (!ClearAutofillProfiles()) {
+          LOG(WARNING) << "Unable to update web database to version 36.";
+          NOTREACHED();
+          return sql::INIT_FAILURE;
+        }
+
+        // Add the newly merged profiles back in.
+        for (std::vector<AutofillProfile>::const_iterator
+                iter = accumulated_profiles.begin();
+             iter != accumulated_profiles.end();
+             ++iter) {
+          if (!AddAutofillProfile(*iter)) {
+            LOG(WARNING) << "Unable to update web database to version 36.";
+            NOTREACHED();
+            return sql::INIT_FAILURE;
+          }
+
+          // Fix up the original modification date.
+          std::map<std::string, int64>::const_iterator date_item =
+              modification_map.find(iter->guid());
+          if (date_item == modification_map.end()) {
+            LOG(WARNING) << "Unable to update web database to version 36.";
+            NOTREACHED();
+            return sql::INIT_FAILURE;
+          }
+          sql::Statement s_date(db_.GetUniqueStatement(
+              "UPDATE autofill_profiles SET date_modified=? "
+              "WHERE guid=?"));
+          s_date.BindInt64(0, date_item->second);
+          s_date.BindString(1, iter->guid());
+          if (!s_date.Run()) {
+            LOG(WARNING) << "Unable to update web database to version 36.";
+            NOTREACHED();
+            return sql::INIT_FAILURE;
+          }
+        }
+      }
+
+      meta_table_.SetVersionNumber(36);
+      meta_table_.SetCompatibleVersionNumber(
+          std::min(36, kCompatibleVersionNumber));
+
+      // FALL THROUGH
+
     // 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 sql::INIT_OK;
   }
 }