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/21 22:33:03]

I'm worried that (if my understanding is correct) this will create updates to
all entries since you're now only storing the first and last timestamps. Some
logic here to simply ignore all intervening timestamps would be good. 

That way, sync entries created previously will retain their current timestamps
until the next time they're updated locally.

[GeorgeY, 2012/03/23 21:53:21]

Updates will be created only for the entries that remain after culling, which
should be minority. Most of the extra entries would get "DELETE", which need to
happen in any case as otherwise it would continue to be synced.

     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 47 matching lines @@
 
   std::vector<AutofillEntry> new_synced_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);
   }
 
+  // Check if newly received items need culling.
+  bool need_to_cull_data = false;
+  for (size_t i = 0; i < new_synced_entries.size() && !need_to_cull_data; ++i) {
+    if (new_synced_entries[i].IsExpired())
+      need_to_cull_data = true;
+  }
+
   if (!SaveChangesToWebData(new_synced_entries))

[Nicolas Zea, 2012/03/21 22:33:03]

It seems odd to add data to the autofill db if you know you'll delete some of
it. Perhaps modify CreateOrUpdateEntry to also check for sync entries that don't
exist locally but are expired, and create DELETE events directly within
MergeDataAndStartSyncing for those.

This will also handle the case where the expiring of local data happens before
sync starts up, and I think should simplify some of this logic (I think you
should be able to get rid of keys_to_ignore)

[GeorgeY, 2012/03/23 21:53:21]

Change was not as simple :), but I added it - expire autofill data from sync are
not written locally anymore.

     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);
+    }
+  }
+
+  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 219 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);
 }