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 trashed profile.
+//
 // 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)) {
+    sql::Statement s_trash(db_.GetUniqueStatement(
+        "DELETE FROM autofill_profiles_trash WHERE guid = ?"));
+    if (!s_trash) {
+      NOTREACHED() << "Statement prepare failed";
+      return false;
+    }
+    s_trash.BindString(0, guid);
+    if (!s_trash.Run()) {
+      NOTREACHED() << "Expected item in trash.";
+      return false;
+    }
+
+    return true;
+  }
+
   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::IsValidLearnableProfile(*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;
   }
 }