[sync] Add autofill sync metadata to the web db

components/autofill/core/browser/webdata/autofill_table.cc

 // Copyright 2013 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 "components/autofill/core/browser/webdata/autofill_table.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 17 matching lines @@
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/credit_card.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/webdata/autofill_change.h"
 #include "components/autofill/core/browser/webdata/autofill_entry.h"
 #include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/autofill_util.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/os_crypt/os_crypt.h"
+#include "components/sync/base/model_type.h"
+#include "components/sync/protocol/entity_metadata.pb.h"
+#include "components/sync/protocol/model_type_state.pb.h"
 #include "components/webdata/common/web_database.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 using base::ASCIIToUTF16;
 using base::Time;
 using base::TimeDelta;
 
@@ skipping 361 matching lines @@
 WebDatabaseTable::TypeKey AutofillTable::GetTypeKey() const {
   return GetKey();
 }
 
 bool AutofillTable::CreateTablesIfNecessary() {
   return (InitMainTable() && InitCreditCardsTable() && InitProfilesTable() &&
           InitProfileNamesTable() && InitProfileEmailsTable() &&
           InitProfilePhonesTable() && InitProfileTrashTable() &&
           InitMaskedCreditCardsTable() && InitUnmaskedCreditCardsTable() &&
           InitServerCardMetadataTable() && InitServerAddressesTable() &&
-          InitServerAddressMetadataTable());
+          InitServerAddressMetadataTable() && InitAutofillSyncMetadataTable() &&
+          InitModelTypeStateTable());
 }
 
 bool AutofillTable::IsSyncable() {
   return true;
 }
 
 bool AutofillTable::MigrateToVersion(int version,
                                      bool* update_compatible_version) {
   // Migrate if necessary.
   switch (version) {
@@ skipping 26 matching lines @@
       return MigrateToVersion64AddUnmaskDate();
     case 65:
       *update_compatible_version = false;
       return MigrateToVersion65AddServerMetadataTables();
     case 66:
       *update_compatible_version = false;
       return MigrateToVersion66AddCardBillingAddress();
     case 67:
       *update_compatible_version = false;
       return MigrateToVersion67AddMaskedCardBillingAddress();
+    case 70:
+      *update_compatible_version = false;
+      return MigrateToVersion70AddSyncMetadata();
   }
   return true;
 }
 
 bool AutofillTable::AddFormFieldValues(
     const std::vector<FormFieldData>& elements,
     std::vector<AutofillChange>* changes) {
   return AddFormFieldValuesTime(elements, changes, Time::Now());
 }
 
@@ skipping 1197 matching lines @@
 bool AutofillTable::IsAutofillGUIDInTrash(const std::string& guid) {
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid "
       "FROM autofill_profiles_trash "
       "WHERE guid = ?"));
   s.BindString(0, guid);
 
   return s.Step();
 }
 
+bool AutofillTable::GetSyncMetadata(syncer::ModelType model_type,
+                                    const std::string& storage_key,
+                                    sync_pb::EntityMetadata* metadata) {
+  DCHECK_EQ(model_type, syncer::AUTOFILL)
+      << "Only the AUTOFILL model type is supported";
+
+  sql::Statement s(db_->GetUniqueStatement(
+      "SELECT value FROM autofill_sync_metadata WHERE storage_key=?"));
+  s.BindString(0, storage_key);
+
+  if (!s.Step()) {
+    return false;
+  }
+
+  std::string serialized_metadata = s.ColumnString(0);
+  return metadata->ParseFromString(serialized_metadata);
+}
+
+bool AutofillTable::GetAllSyncMetadata(
+    syncer::ModelType model_type,
+    std::vector<sync_pb::EntityMetadata>* metadata_records) {
+  DCHECK_EQ(model_type, syncer::AUTOFILL)
+      << "Only the AUTOFILL model type is supported";
+
+  sql::Statement s(
+      db_->GetUniqueStatement("SELECT value FROM autofill_sync_metadata"));
+
+  while (s.Step()) {
+    std::string serialized_metadata = s.ColumnString(0);
+    sync_pb::EntityMetadata metadata_record;
+    //todo(pnoland): account for unparseable entries.
+    if (metadata_record.ParseFromString(serialized_metadata)) {
+      metadata_records->push_back(metadata_record);
+    }
+  }
+  return true;
+}
+
+bool AutofillTable::UpdateSyncMetadata(
+    syncer::ModelType model_type,
+    const std::string& storage_key,
+    const sync_pb::EntityMetadata& metadata) {
+  DCHECK_EQ(model_type, syncer::AUTOFILL)
+      << "Only the AUTOFILL model type is supported";
+
+  sql::Statement s(
+      db_->GetUniqueStatement("INSERT OR REPLACE INTO autofill_sync_metadata "
+                              "(storage_key, value) VALUES(?, ?)"));
+  s.BindString(0, storage_key);
+  s.BindString(1, metadata.SerializeAsString());
+
+  return s.Run();
+}
+
+bool AutofillTable::ClearSyncMetadata(syncer::ModelType model_type,
+                                      const std::string& storage_key) {
+  DCHECK_EQ(model_type, syncer::AUTOFILL)
+      << "Only the AUTOFILL model type is supported";
+
+  sql::Statement s(db_->GetUniqueStatement(
+      "DELETE FROM autofill_sync_metadata WHERE storage_key=?"));
+  s.BindString(0, storage_key);
+
+  return s.Run();
+}
+
+bool AutofillTable::GetModelTypeState(syncer::ModelType model_type,
+                                      sync_pb::ModelTypeState* state) {
+  DCHECK_EQ(model_type, syncer::AUTOFILL)
+      << "Only the AUTOFILL model type is supported";
+
+  sql::Statement s(
+      db_->GetUniqueStatement("SELECT value FROM autofill_model_type_state"));
+
+  if (!s.Step()) {
+    return false;
+  }
+
+  std::string serialized_state = s.ColumnString(0);
+  return state->ParseFromString(serialized_state);
+}
+
+bool AutofillTable::UpdateModelTypeState(
+    syncer::ModelType model_type,
+    sync_pb::ModelTypeState& model_type_state) {
+  DCHECK_EQ(model_type, syncer::AUTOFILL)
+      << "Only the AUTOFILL model type is supported";
+
+  // Hardcode the rowid to force a collision, ensuring that there remains only a
+  // single entry.
+  sql::Statement s(db_->GetUniqueStatement(
+      "INSERT OR REPLACE INTO autofill_model_type_state (rowid, value) "
+      "VALUES(1,?)"));
+  s.BindString(0, model_type_state.SerializeAsString());
+
+  return s.Run();
+}
+
+bool AutofillTable::ClearModelTypeState(syncer::ModelType model_type) {
+  DCHECK_EQ(model_type, syncer::AUTOFILL)
+      << "Only the AUTOFILL model type is supported";
+
+  sql::Statement s(
+      db_->GetUniqueStatement("DELETE FROM autofill_model_type_state"));
+
+  return s.Run();
+}
+
 bool AutofillTable::InitMainTable() {
   if (!db_->DoesTableExist("autofill")) {
     if (!db_->Execute("CREATE TABLE autofill ("
                       "name VARCHAR, "
                       "value VARCHAR, "
                       "value_lower VARCHAR, "
                       "date_created INTEGER DEFAULT 0, "
                       "date_last_used INTEGER DEFAULT 0, "
                       "count INTEGER DEFAULT 1, "
                       "PRIMARY KEY (name, value))") ||
@@ skipping 179 matching lines @@
                       "id VARCHAR NOT NULL,"
                       "use_count INTEGER NOT NULL DEFAULT 0, "
                       "use_date INTEGER NOT NULL DEFAULT 0)")) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
+bool AutofillTable::InitAutofillSyncMetadataTable() {
+  if (!db_->DoesTableExist("autofill_sync_metadata")) {
+    if (!db_->Execute("CREATE TABLE autofill_sync_metadata ("
+                      "storage_key VARCHAR primary key,"
+                      "value BLOB)")) {

[Scott Hess - ex-Googler, 2016/12/07 23:15:20]

I'd drop a NOT NULL in there.  PRIMARY KEY does not imply NOT NULL in SQLite,
see https://www.sqlite.org/lang_createtable.html#constraints .

Also, PRIMARY KEY to be consistent with your other capitalization of SQL code.

Obviously same deal in the migrate code.

Rather than testing for existence then creating, instead consider CREATE TABLE
IF NOT EXISTS.  It succeeds if a table of that name already exists.  [Not
suggesting that for the migrate case, since the expected db state is different
there.]  [[Hmm, and I guess there's the argument from consistency with prior
code, so I don't consider that a blocker.]]

[Patrick Noland, 2016/12/08 22:51:13]

I've added the NOT NULL constraint, but I'm leaving the if-else structure as is
to be consistent with other code.

[Scott Hess - ex-Googler, 2016/12/08 23:24:01]

Acknowledged.

+      NOTREACHED();
+      return false;
+    }
+  }
+  return true;
+}
+
+bool AutofillTable::InitModelTypeStateTable() {
+  if (!db_->DoesTableExist("autofill_model_type_state")) {
+    if (!db_->Execute("CREATE TABLE autofill_model_type_state (value BLOB)")) {
+      NOTREACHED();
+      return false;
+    }
+  }
+  return true;
+}
+
 bool AutofillTable::MigrateToVersion54AddI18nFieldsAndRemoveDeprecatedFields() {
   sql::Transaction transaction(db_);
   if (!transaction.Begin())
     return false;
 
   // Test the existence of the |address_line_1| column as an indication that a
   // migration is needed.  It is possible that the new |autofill_profile_phones|
   // schema is in place because the table was newly created when migrating from
   // a pre-version-23 database.
   if (db_->DoesColumnExist("autofill_profiles", "address_line_1")) {
@@ skipping 416 matching lines @@
       "ALTER TABLE credit_cards ADD COLUMN billing_address_id VARCHAR");
 }
 
 bool AutofillTable::MigrateToVersion67AddMaskedCardBillingAddress() {
   // The default value for this column is null, but Connection::ColumnString()
   // returns an empty string for that.
   return db_->Execute(
       "ALTER TABLE masked_credit_cards ADD COLUMN billing_address_id VARCHAR");
 }
 
-}  // namespace autofill
+bool AutofillTable::MigrateToVersion70AddSyncMetadata() {
+  if (!db_->Execute("CREATE TABLE autofill_sync_metadata ("
+                    "storage_key VARCHAR primary key,"
+                    "value BLOB)")) {
+    return false;
+  }
+

[Mathieu, 2016/12/07 16:17:42]

nit: remove extra line to be consistent

[Patrick Noland, 2016/12/08 22:51:14]

Done.

+  return db_->Execute("CREATE TABLE autofill_model_type_state (value BLOB)");

[Scott Hess - ex-Googler, 2016/12/07 23:15:20]

This probably wants a transaction to keep these atomic.  Though I guess the
caller _must_ have a transaction so that bumping the version happens atomically
with the migration?  Well, in that case the transaction is cheap.

[Patrick Noland, 2016/12/08 22:51:13]

Migration functions are called in the context of a transaction already:
https://cs.chromium.org/chromium/src/components/webdata/common/web_database.c...

[Scott Hess - ex-Googler, 2016/12/08 23:24:01]

Acknowledged.

+}
+
+}  // namespace autofill