Cull autofill entries older than 60 days.

chrome/browser/webdata/autofill_entry.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/autofill_entry.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/logging.h"
-#include "chrome/browser/webdata/autofill_entry.h"
 #include "base/utf_string_conversions.h"
 
 AutofillKey::AutofillKey() {}
 
 AutofillKey::AutofillKey(const string16& name, const string16& value)
     : name_(name),
       value_(value) {
 }
 
 AutofillKey::AutofillKey(const char* name, const char* value)
@@ skipping 45 matching lines @@
       return false;
   }
 
   return true;
 }
 
 bool AutofillEntry::operator<(const AutofillEntry& entry) const {
   return key_ < entry.key();
 }
 
+bool AutofillEntry::HasTimestampsOlder(base::Time time) const {
+  for (size_t i = 0; i < timestamps_.size(); ++i)

[Ilya Sherman, 2012/03/06 08:48:35]

nit: The loop body is more than one line, so please add curly braces.

[GeorgeY, 2012/03/09 20:14:24]

Done.

+    if (timestamps_[i] < time)
+      return true;
+  return false;
+}
+
+bool AutofillEntry::CullExpiredTimeStamps(base::Time expire_before) {
+  std::vector<base::Time> new_timestamps;
+  new_timestamps.reserve(timestamps_.size());
+
+  for (size_t i = 0; i < timestamps_.size(); ++i) {
+    if (timestamps_[i] >= expire_before) {
+      new_timestamps.push_back(timestamps_[i]);
+    }

[Ilya Sherman, 2012/03/06 08:48:35]

nit: One-line if-stmt, so no need for curlys.

[GeorgeY, 2012/03/09 20:14:24]

Done.

+  }
+
+  if (timestamps_.size() == new_timestamps.size())
+    return false;
+
+  timestamps_.swap(new_timestamps);
+  timestamps_culled_ = true;

[Ilya Sherman, 2012/03/06 08:48:35]

It seems a little odd to me that we're using timestamps_culled_ to mean two
different things...  Why does one type of culling happen in the constructor,
whereas the other type is initiated externally?

[GeorgeY, 2012/03/09 20:14:24]

Because the original culling just limits the number of timestamps taken in the
consideration, they are *not* deleted from anywhere, they just not used (or
synced). Time culling on the other hand is a more involved operation, as it is
done both on the object and with the db, so it is done occasionally externally.
In both cases |timestamps_culled_|  means that the object was changed and needs
to be re-synced.

+  return true;
+}
+
 // Culls the list of timestamps to the most recent |kMaxAutofillTimeStamps|.
 // If sync is enabled, at every browser restart, sync will do a match up of all
 // autofill items on the server with all items on the web db. When webdb loads
 // all the items in memory(for sync to process. The method is
 // |GetAllAutofillEntries|) they will pass through this method for culling. If
 // sync finds any of these items were culled it will updates the server AND the
 // web db with these new timestamps. However after restart if an autofill item
 // exceeds the |kMaxAutofillTimeStamps| it will NOT be written to web db until
 // restart. But sync when uploading to the server will only upload this culled
 // list. Meaning until restart there will be mis-match in timestamps but
@@ skipping 14 matching lines @@
   VLOG(1) << "Culling timestamps. Current count is : " << source.size();
 
   // Regular sort does ascending order. So we pass in a comparator function.
   partial_sort(result->begin(), result->begin() + kMaxAutofillTimeStamps,
                result->end(), std::greater<base::Time>());
 
   result->erase(result->begin() + kMaxAutofillTimeStamps, result->end());
 
   return true;
 }