[Autofill] Sync the new validity state bitfield.

Bug: 748223
Change-Id: I93fd4f4e326fe5b272ae4b8816a3c744621b3949
Reviewed-on: https://chromium-review.googlesource.com/675768
Commit-Queue: Sebastien Seguin-Gagnon <sebsg@chromium.org>
Reviewed-by: Roger McFarlane <rogerm@chromium.org>
Reviewed-by: Nicolas Zea <zea@chromium.org>
Cr-Commit-Position: refs/heads/master@{#505896}

components/autofill/core/browser/autofill_profile.cc

@@ -192,19 +192,24 @@ void GetFieldsForDistinguishingProfiles(
 }
 
 // Constants for the validity bitfield.
-static const size_t validity_bits_per_type = 2;
-static const size_t number_supported_types_for_validation = 7;
+static const size_t kValidityBitsPerType = 2;
 // The order is important to ensure a consistent bitfield value. New values
 // should be added at the end NOT at the start or middle.
-static const ServerFieldType
-    supported_types_for_validation[number_supported_types_for_validation] = {
-        ADDRESS_HOME_COUNTRY,
-        ADDRESS_HOME_STATE,
-        ADDRESS_HOME_ZIP,
-        ADDRESS_HOME_CITY,
-        ADDRESS_HOME_DEPENDENT_LOCALITY,
-        EMAIL_ADDRESS,
-        PHONE_HOME_WHOLE_NUMBER};
+static const ServerFieldType kSupportedTypesForValidation[] = {
+    ADDRESS_HOME_COUNTRY,
+    ADDRESS_HOME_STATE,
+    ADDRESS_HOME_ZIP,
+    ADDRESS_HOME_CITY,
+    ADDRESS_HOME_DEPENDENT_LOCALITY,
+    EMAIL_ADDRESS,
+    PHONE_HOME_WHOLE_NUMBER};
+
+static const size_t kNumSupportedTypesForValidation =
+    sizeof(kSupportedTypesForValidation) /
+    sizeof(kSupportedTypesForValidation[0]);
+
+static_assert(kNumSupportedTypesForValidation * kValidityBitsPerType <= 64,
+              "Not enough bits to encode profile validity information!");
 
 }  // namespace
 
@@ -263,6 +268,7 @@ AutofillProfile& AutofillProfile::operator=(const AutofillProfile& profile) {
 
   server_id_ = profile.server_id();
   has_converted_ = profile.has_converted();
+  SetValidityFromBitfieldValue(profile.GetValidityBitfieldValue());
 
   return *this;
 }
@@ -363,6 +369,7 @@ int AutofillProfile::Compare(const AutofillProfile& profile) const {
 bool AutofillProfile::EqualsSansOrigin(const AutofillProfile& profile) const {
   return guid() == profile.guid() &&
          language_code() == profile.language_code() &&
+         GetValidityBitfieldValue() == profile.GetValidityBitfieldValue() &&
          Compare(profile) == 0;
 }
 
@@ -717,42 +724,38 @@ void AutofillProfile::SetValidityState(ServerFieldType type,
   if (!IsValidationSupportedForType(type))
     return;
 
-  std::map<ServerFieldType, ValidityState>::iterator it =
-      validity_states_.find(type);
-
-  if (it != validity_states_.end()) {
-    it->second = validity;
-  } else {
-    validity_states_.insert(std::make_pair(type, validity));
-  }
+  validity_states_[type] = validity;
 }
 
 bool AutofillProfile::IsValidationSupportedForType(ServerFieldType type) const {
-  return std::find(supported_types_for_validation,
-                   supported_types_for_validation +
-                       number_supported_types_for_validation,
-                   type) !=
-         supported_types_for_validation + number_supported_types_for_validation;
+  for (auto supported_type : kSupportedTypesForValidation) {
+    if (type == supported_type)
+      return true;
+  }
+  return false;
 }
 
 int AutofillProfile::GetValidityBitfieldValue() const {
   int validity_value = 0;
   size_t field_type_shift = 0;
-  for (ServerFieldType supported_type : supported_types_for_validation) {
+  for (ServerFieldType supported_type : kSupportedTypesForValidation) {
     DCHECK(GetValidityState(supported_type) != UNSUPPORTED);
     validity_value |= GetValidityState(supported_type) << field_type_shift;
-    field_type_shift += validity_bits_per_type;
+    field_type_shift += kValidityBitsPerType;
   }
 
+  // Check the the shift is still in range.
+  DCHECK_LE(field_type_shift, 64U);
+
   return validity_value;
 }
 
 void AutofillProfile::SetValidityFromBitfieldValue(int bitfield_value) {
   // Compute the bitmask based on the number a bits per type. For example, this
   // could be the two least significant bits (0b11).
-  const int kBitmask = (1 << validity_bits_per_type) - 1;
+  const int kBitmask = (1 << kValidityBitsPerType) - 1;
 
-  for (ServerFieldType supported_type : supported_types_for_validation) {
+  for (ServerFieldType supported_type : kSupportedTypesForValidation) {
     // Apply the bitmask to the bitfield value to get the validity value of the
     // current |supported_type|.
     int validity_value = bitfield_value & kBitmask;
@@ -765,7 +768,7 @@ void AutofillProfile::SetValidityFromBitfieldValue(int bitfield_value) {
                      static_cast<ValidityState>(validity_value));
 
     // Shift the bitfield value to access the validity of the next field type.
-    bitfield_value = bitfield_value >> validity_bits_per_type;
+    bitfield_value = bitfield_value >> kValidityBitsPerType;
   }
 }
 
@@ -928,6 +931,7 @@ FormGroup* AutofillProfile::MutableFormGroupForType(const AutofillType& type) {
 bool AutofillProfile::EqualsSansGuid(const AutofillProfile& profile) const {
   return origin() == profile.origin() &&
          language_code() == profile.language_code() &&
+         GetValidityBitfieldValue() == profile.GetValidityBitfieldValue() &&
          Compare(profile) == 0;
 }
 
@@ -948,7 +952,8 @@ std::ostream& operator<<(std::ostream& os, const AutofillProfile& profile) {
             << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_SORTING_CODE)) << " "
             << UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_COUNTRY)) << " "
             << profile.language_code() << " "
-            << UTF16ToUTF8(profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER));
+            << UTF16ToUTF8(profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER)) << " "
+            << profile.GetValidityBitfieldValue();
 }
 
 }  // namespace autofill

components/autofill/core/browser/autofill_profile.h

@@ -99,7 +99,7 @@ class AutofillProfile : public AutofillDataModel {
   bool EqualsSansOrigin(const AutofillProfile& profile) const;
 
   // Same as operator==, but ignores differences in guid and cares about
-  // differences in usage stats.
+  // differences in usage stats and validity state.
   bool EqualsForSyncPurposes(const AutofillProfile& profile) const;
 
   // Equality operators compare GUIDs, origins, language code, and the contents

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

@@ -407,6 +407,14 @@ bool AutofillProfileSyncableService::OverwriteProfileWithServerData(
     diff = true;
   }
 
+  // Update the validity state bitfield.
+  if (specifics.has_validity_state_bitfield() &&
+      specifics.validity_state_bitfield() !=
+          profile->GetValidityBitfieldValue()) {
+    profile->SetValidityFromBitfieldValue(specifics.validity_state_bitfield());
+    diff = true;
+  }
+
   if (static_cast<size_t>(specifics.use_count()) != profile->use_count()) {
     profile->set_use_count(specifics.use_count());
     diff = true;
@@ -471,6 +479,7 @@ void AutofillProfileSyncableService::WriteAutofillProfile(
       LimitData(
           UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY))));
   specifics->set_address_home_language_code(LimitData(profile.language_code()));
+  specifics->set_validity_state_bitfield(profile.GetValidityBitfieldValue());
 
   // TODO(estade): this should be set_email_address.
   specifics->add_email_address(

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

@@ -1087,14 +1087,15 @@ bool AutofillTable::UpdateAutofillProfile(const AutofillProfile& profile) {
       "UPDATE autofill_profiles "
       "SET guid=?, company_name=?, street_address=?, dependent_locality=?, "
       "    city=?, state=?, zipcode=?, sorting_code=?, country_code=?, "
-      "    use_count=?, use_date=?, date_modified=?, origin=?, language_code=? "
+      "    use_count=?, use_date=?, date_modified=?, origin=?, "
+      "    language_code=?, validity_bitfield=? "
       "WHERE guid=?"));
   BindAutofillProfileToStatement(profile,
                                  update_modification_date
                                      ? AutofillClock::Now()
                                      : old_profile->modification_date(),
                                  &s);
-  s.BindString(14, profile.guid());
+  s.BindString(15, profile.guid());
 
   bool result = s.Run();
   DCHECK_GT(db_->GetLastChangeCount(), 0);

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

@@ -1635,6 +1635,19 @@ TEST_F(AutofillTableTest, AutofillProfileValidityBitfield) {
       table_->GetAutofillProfile(profile.guid());
   ASSERT_TRUE(db_profile);
   EXPECT_EQ(kValidityBitfieldValue, db_profile->GetValidityBitfieldValue());
+
+  // Modify the validity of the profile.
+  const int kOtherValidityBitfieldValue = 1999;
+  profile.SetValidityFromBitfieldValue(kOtherValidityBitfieldValue);
+
+  // Update the profile in the table.
+  EXPECT_TRUE(table_->UpdateAutofillProfile(profile));
+
+  // Get the profile from the table and make sure the validity was updated.
+  db_profile = table_->GetAutofillProfile(profile.guid());
+  ASSERT_TRUE(db_profile);
+  EXPECT_EQ(kOtherValidityBitfieldValue,
+            db_profile->GetValidityBitfieldValue());
 }
 
 TEST_F(AutofillTableTest, SetGetServerCards) {

components/sync/protocol/autofill_specifics.proto

@@ -51,6 +51,11 @@ message AutofillProfileSpecifics {
   // Phone.
   repeated string phone_home_whole_number = 13;
 
+  // Validity bitfield.
+  // Each set of two bits represents the validity state of a specific part of
+  // the Autofill address. For more info please refer to autofill_profile.h.
+  optional int64 validity_state_bitfield = 24;
+
   // Deprecated.
   optional string label = 1 [deprecated = true];
   optional string phone_fax_whole_number = 14 [deprecated = true];

components/sync/protocol/proto_visitors.h

@@ -188,6 +188,7 @@ VISIT_PROTO_FIELDS(const sync_pb::AutofillProfileSpecifics& proto) {
   VISIT(address_home_dependent_locality);
   VISIT(address_home_language_code);
   VISIT_REP(phone_home_whole_number);
+  VISIT(validity_state_bitfield);
 }
 
 VISIT_PROTO_FIELDS(const sync_pb::AutofillSpecifics& proto) {