Cull autofill entries older than 60 days.

chrome/browser/webdata/autocomplete_syncable_service.cc

 // Copyright (c) 2012 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/autocomplete_syncable_service.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 22 matching lines @@
 bool MergeTimestamps(const sync_pb::AutofillSpecifics& autofill,
                      const std::vector<base::Time>& timestamps,
                      std::vector<base::Time>* new_timestamps) {
   DCHECK(new_timestamps);
   std::set<base::Time> timestamp_union(timestamps.begin(),
                                        timestamps.end());
 
   size_t timestamps_count = autofill.usage_timestamp_size();
 
   bool different = timestamps.size() != timestamps_count;
   for (size_t i = 0; i < timestamps_count; ++i) {

[Nicolas Zea, 2012/03/26 18:23:55]

This shouldn't union, but instead just check first/last timestamps, and if
they're different update them.

[GeorgeY, 2012/03/26 19:59:10]

Done.

     if (timestamp_union.insert(base::Time::FromInternalValue(
             autofill.usage_timestamp(i))).second) {
       different = true;
     }
   }
 
   if (different) {
     new_timestamps->insert(new_timestamps->begin(),
                            timestamp_union.begin(),
                            timestamp_union.end());
@@ skipping 39 matching lines @@
 
   AutocompleteEntryMap new_db_entries;
   for (std::vector<AutofillEntry>::iterator it = entries.begin();
        it != entries.end(); ++it) {
     new_db_entries[it->key()] = std::make_pair(SyncChange::ACTION_ADD, it);
   }
 
   sync_processor_.reset(sync_processor);
 
   std::vector<AutofillEntry> new_synced_entries;
+  std::vector<AutofillEntry> synced_expired_entries;
   // Go through and check for all the entries that sync already knows about.
   // CreateOrUpdateEntry() will remove entries that are same with the synced
   // ones from |new_db_entries|.
   for (SyncDataList::const_iterator sync_iter = initial_sync_data.begin();
        sync_iter != initial_sync_data.end(); ++sync_iter) {
-    CreateOrUpdateEntry(*sync_iter, &new_db_entries, &new_synced_entries);
+    CreateOrUpdateEntry(*sync_iter, &new_db_entries,
+                        &new_synced_entries, &synced_expired_entries);
   }
 
+  // Check if newly received items need culling.
+  bool need_to_cull_data = !synced_expired_entries.empty();
+
   if (!SaveChangesToWebData(new_synced_entries))
     return SyncError(FROM_HERE, "Failed to update webdata.", model_type());
 
   WebDataService::NotifyOfMultipleAutofillChanges(web_data_service_);
+  keys_to_ignore_.clear();
 
   SyncChangeList new_changes;
   for (AutocompleteEntryMap::iterator i = new_db_entries.begin();
        i != new_db_entries.end(); ++i) {
-    new_changes.push_back(
-        SyncChange(i->second.first, CreateSyncData(*(i->second.second))));
+    // Sync back only the data that appeared after
+    // |AutofillEntry::ExpirationTime()|.
+    if (!i->second.second->IsExpired()) {
+      new_changes.push_back(
+          SyncChange(i->second.first, CreateSyncData(*(i->second.second))));
+    } else {
+      need_to_cull_data = true;
+      // Key is not on the server and is too old, it will not ever be synced -
+      // delete it locally.
+      if (i->second.first == SyncChange::ACTION_ADD)
+        keys_to_ignore_.insert(i->first);
+    }
+  }
+
+  // Delete only the changes never synced  to the db as they are too old.

[Ilya Sherman, 2012/03/23 22:44:45]

nit: "synced  to" -> "synced to" (extra space)

[GeorgeY, 2012/03/26 19:59:10]

Done.

+  for (size_t i = 0; i < synced_expired_entries.size(); ++i) {
+    // Key is on the server and not local and is too old, we need to notify
+    // sync that it has expired.
+    if (keys_to_ignore_.find(synced_expired_entries[i].key()) ==
+        keys_to_ignore_.end()) {
+      new_changes.push_back(SyncChange(SyncChange::ACTION_DELETE,
+          CreateSyncData(synced_expired_entries[i])));
+    }
+  }
+
+  if (need_to_cull_data) {
+    // This will schedule deletion operation later on DB thread and we will
+    // be notified on the results of the deletion and deletes will be synced to
+    // the sync.
+    web_data_service_->RemoveExpiredFormElements();
   }
 
   SyncError error = sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
 
   return error;
 }
 
 void AutocompleteSyncableService::StopSyncing(syncable::ModelType type) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(syncable::AUTOFILL, type);
@@ skipping 30 matching lines @@
   if (!sync_processor_.get()) {
     SyncError error(FROM_HERE, "Models not yet associated.",
                     syncable::AUTOFILL);
     return error;
   }
 
   // Data is loaded only if we get new ADD/UPDATE change.
   std::vector<AutofillEntry> entries;
   scoped_ptr<AutocompleteEntryMap> db_entries;
   std::vector<AutofillEntry> new_entries;
+  std::vector<AutofillEntry> ignored_entries;
 
   SyncError list_processing_error;
 
   for (SyncChangeList::const_iterator i = change_list.begin();
        i != change_list.end() && !list_processing_error.IsSet(); ++i) {
     DCHECK(i->IsValid());
     switch (i->change_type()) {
       case SyncChange::ACTION_ADD:
       case SyncChange::ACTION_UPDATE:
         if (!db_entries.get()) {
           if (!LoadAutofillData(&entries)) {
             return SyncError(
                 FROM_HERE,
                 "Could not get the autocomplete data from WebDatabase.",
                 model_type());
           }
           db_entries.reset(new AutocompleteEntryMap);
           for (std::vector<AutofillEntry>::iterator it = entries.begin();
                it != entries.end(); ++it) {
             (*db_entries)[it->key()] =
                 std::make_pair(SyncChange::ACTION_ADD, it);
           }
         }
-        CreateOrUpdateEntry(i->sync_data(), db_entries.get(), &new_entries);
+        CreateOrUpdateEntry(i->sync_data(), db_entries.get(),
+                            &new_entries, &ignored_entries);
         break;
       case SyncChange::ACTION_DELETE: {
         DCHECK(i->sync_data().GetSpecifics().has_autofill())
             << "Autofill specifics data not present on delete!";
         const sync_pb::AutofillSpecifics& autofill =
             i->sync_data().GetSpecifics().autofill();
         if (autofill.has_value()) {
           list_processing_error = AutofillEntryDelete(autofill);
         } else {
           DLOG(WARNING)
               << "Delete for old-style autofill profile being dropped!";
         }
       } break;
       default:
         NOTREACHED() << "Unexpected sync change state.";
         return SyncError(FROM_HERE, "ProcessSyncChanges failed on ChangeType " +
                          SyncChange::ChangeTypeToString(i->change_type()),
                          syncable::AUTOFILL);
     }
   }
 
   if (!SaveChangesToWebData(new_entries))
     return SyncError(FROM_HERE, "Failed to update webdata.", model_type());
 
+  // Remove already expired data.
+  for (size_t i = 0; i < ignored_entries.size(); ++i) {
+    if (db_entries.get() &&
+        db_entries->find(ignored_entries[i].key()) != db_entries->end()) {
+      if (!web_data_service_->GetDatabase()->GetAutofillTable()->
+              RemoveFormElement(ignored_entries[i].key().name(),
+                                ignored_entries[i].key().value())) {
+        NOTREACHED();
+      }

[Ilya Sherman, 2012/03/23 22:44:45]

nit: Up to you, but I think this would be a little clearer if it was written as

bool success = web_data_service_->GetDatabase()...
DCHECK(success);

[GeorgeY, 2012/03/26 19:59:10]

Done.

+    }
+  }
+
   WebDataService::NotifyOfMultipleAutofillChanges(web_data_service_);
 
   return list_processing_error;
 }
 
 void AutocompleteSyncableService::Observe(int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_AUTOFILL_ENTRIES_CHANGED, type);
 
@@ skipping 27 matching lines @@
           GetAutofillTable()->UpdateAutofillEntries(new_entries)) {
     return false;
   }
   return true;
 }
 
 // Creates or updates an autocomplete entry based on |data|.
 void AutocompleteSyncableService::CreateOrUpdateEntry(
     const SyncData& data,
     AutocompleteEntryMap* loaded_data,
-    std::vector<AutofillEntry>* new_entries) {
+    std::vector<AutofillEntry>* new_entries,
+    std::vector<AutofillEntry>* ignored_entries) {
   const sync_pb::EntitySpecifics& specifics = data.GetSpecifics();
   const sync_pb::AutofillSpecifics& autofill_specifics(
       specifics.autofill());
 
   if (!autofill_specifics.has_value()) {
     DLOG(WARNING)
         << "Add/Update for old-style autofill profile being dropped!";
     return;
   }
 
   AutofillKey key(autofill_specifics.name().c_str(),
                   autofill_specifics.value().c_str());
   AutocompleteEntryMap::iterator it = loaded_data->find(key);
   if (it == loaded_data->end()) {
     // New entry.
     std::vector<base::Time> timestamps;
     size_t timestamps_count = autofill_specifics.usage_timestamp_size();
     timestamps.resize(timestamps_count);
     for (size_t ts = 0; ts < timestamps_count; ++ts) {
       timestamps[ts] = base::Time::FromInternalValue(
             autofill_specifics.usage_timestamp(ts));

[Nicolas Zea, 2012/03/26 18:23:55]

this should probably only look at the first and last timestamps as well, since
older clients are still going to be creating specifics with all the timestamps.

[GeorgeY, 2012/03/26 19:59:10]

Done.

     }
-    new_entries->push_back(AutofillEntry(key, timestamps));
+    AutofillEntry new_entry(key, timestamps);
+    if (new_entry.IsExpired())
+      ignored_entries->push_back(new_entry);
+    else
+      new_entries->push_back(new_entry);
   } else {
     // Entry already present - merge if necessary.
     std::vector<base::Time> timestamps;
     bool different = MergeTimestamps(
         autofill_specifics, it->second.second->timestamps(), &timestamps);
     if (different) {
       AutofillEntry new_entry(it->second.second->key(), timestamps);
-      new_entries->push_back(new_entry);
+      if (new_entry.IsExpired())
+        ignored_entries->push_back(new_entry);
+      else
+        new_entries->push_back(new_entry);
 
       // Update the sync db if the list of timestamps have changed.
       *(it->second.second) = new_entry;
       it->second.first = SyncChange::ACTION_UPDATE;
     } else {
       loaded_data->erase(it);
     }
   }
 }
 
@@ skipping 42 matching lines @@
         }
         AutofillEntry entry(change->key(), timestamps);
         SyncChange::SyncChangeType change_type =
            (change->type() == AutofillChange::ADD) ?
                SyncChange::ACTION_ADD : SyncChange::ACTION_UPDATE;
         new_changes.push_back(SyncChange(change_type,
                                          CreateSyncData(entry)));
         break;
       }
       case AutofillChange::REMOVE: {
-        std::vector<base::Time> timestamps;
-        AutofillEntry entry(change->key(), timestamps);
-        new_changes.push_back(SyncChange(SyncChange::ACTION_DELETE,
-                                         CreateSyncData(entry)));
+        if (keys_to_ignore_.find(change->key()) == keys_to_ignore_.end()) {
+          std::vector<base::Time> timestamps;
+          AutofillEntry entry(change->key(), timestamps);
+          new_changes.push_back(SyncChange(SyncChange::ACTION_DELETE,
+                                           CreateSyncData(entry)));
+        }
         break;
       }
       default:
         NOTREACHED();
         break;
     }
   }
   SyncError error = sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
   if (error.IsSet()) {
     DLOG(WARNING) << "[AUTOCOMPLETE SYNC]"
                   << " Failed processing change:"
                   << " Error:" << error.message();
   }
+  // |keys_to_ignore_| are only needed for the very first notification.
+  keys_to_ignore_.clear();
 }
 
 SyncData AutocompleteSyncableService::CreateSyncData(
     const AutofillEntry& entry) const {
   sync_pb::EntitySpecifics autofill_specifics;
   WriteAutofillEntry(entry, &autofill_specifics);
   std::string tag(KeyToTag(UTF16ToUTF8(entry.key().name()),
                            UTF16ToUTF8(entry.key().value())));
   return SyncData::CreateLocalData(tag, tag, autofill_specifics);
 }
 
 // static
 std::string AutocompleteSyncableService::KeyToTag(const std::string& name,
                                                   const std::string& value) {
   std::string ns(kAutofillEntryNamespaceTag);
   return ns + net::EscapePath(name) + "|" + net::EscapePath(value);
 }