Add date_synced to PasswordForm.

chrome/browser/password_manager/native_backend_kwallet_x_unittest.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 <algorithm>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 136 matching lines @@
     old_form_google_.password_element = UTF8ToUTF16("pass");
     old_form_google_.password_value = UTF8ToUTF16("seekrit");
     old_form_google_.submit_element = UTF8ToUTF16("submit");
     old_form_google_.signon_realm = "Google";
 
     form_google_ = old_form_google_;
     form_google_.times_used = 3;
     form_google_.type = PasswordForm::TYPE_GENERATED;
     form_google_.form_data.name = UTF8ToUTF16("form_name");
     form_google_.form_data.user_submitted = true;
+    form_google_.date_synced = base::Time::Now();
 
     form_isc_.origin = GURL("http://www.isc.org/");
     form_isc_.action = GURL("http://www.isc.org/auth");
     form_isc_.username_element = UTF8ToUTF16("id");
     form_isc_.username_value = UTF8ToUTF16("janedoe");
     form_isc_.password_element = UTF8ToUTF16("passwd");
     form_isc_.password_value = UTF8ToUTF16("ihazabukkit");
     form_isc_.submit_element = UTF8ToUTF16("login");
     form_isc_.signon_realm = "ISC";
+    form_isc_.date_synced = base::Time::Now();
   }
 
   static void CheckPasswordForm(const PasswordForm& expected,
                                 const PasswordForm& actual);
   static void CheckPasswordChanges(const PasswordStoreChangeList& expected,
                                    const PasswordStoreChangeList& actual);
 
   PasswordForm old_form_google_;
   PasswordForm form_google_;
   PasswordForm form_isc_;
 };
 
 void NativeBackendKWalletTestBase::CheckPasswordForm(
     const PasswordForm& expected, const PasswordForm& actual) {
   EXPECT_EQ(expected.origin, actual.origin);
   EXPECT_EQ(expected.password_value, actual.password_value);
   EXPECT_EQ(expected.action, actual.action);
   EXPECT_EQ(expected.username_element, actual.username_element);
   EXPECT_EQ(expected.username_value, actual.username_value);
   EXPECT_EQ(expected.password_element, actual.password_element);
   EXPECT_EQ(expected.submit_element, actual.submit_element);
   EXPECT_EQ(expected.signon_realm, actual.signon_realm);
   EXPECT_EQ(expected.ssl_valid, actual.ssl_valid);
   EXPECT_EQ(expected.preferred, actual.preferred);
   // We don't check the date created. It varies.
   EXPECT_EQ(expected.blacklisted_by_user, actual.blacklisted_by_user);
   EXPECT_EQ(expected.type, actual.type);
   EXPECT_EQ(expected.times_used, actual.times_used);
   EXPECT_EQ(expected.scheme, actual.scheme);
+  EXPECT_EQ(expected.date_synced, actual.date_synced);
 }
 
 void NativeBackendKWalletTestBase::CheckPasswordChanges(
     const PasswordStoreChangeList& expected,
     const PasswordStoreChangeList& actual) {
   ASSERT_EQ(expected.size(), actual.size());
   for (size_t i = 0; i < expected.size(); ++i) {
     EXPECT_EQ(expected[i].type(), actual[i].type());
     CheckPasswordForm(expected[i].form(), actual[i].form());
   }
@@ skipping 582 matching lines @@
   ExpectationArray expected;
   expected.push_back(make_pair(std::string(form_google_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
 // TODO(mdm): add more basic tests here at some point.
 // (For example tests for storing >1 password per realm pickle.)
 
 class NativeBackendKWalletPickleTest : public NativeBackendKWalletTestBase {
  protected:
+  void CreateVersion2Pickle(const PasswordForm& form, Pickle* pickle);
   void CreateVersion1Pickle(const PasswordForm& form, Pickle* pickle);
   void CreateVersion0Pickle(bool size_32,
                             const PasswordForm& form,
                             Pickle* pickle);
+  void CheckVersion2Pickle();
   void CheckVersion1Pickle();
   void CheckVersion0Pickle(bool size_32, PasswordForm::Scheme scheme);
 
  private:
   void CreatePickle(bool size_32, const PasswordForm& form, Pickle* pickle);
 };
 
+void NativeBackendKWalletPickleTest::CreateVersion2Pickle(
+    const PasswordForm& form, Pickle* pickle) {
+  pickle->WriteInt(2);
+  CreatePickle(false, form, pickle);
+  pickle->WriteInt(form.type);
+  pickle->WriteInt(form.times_used);
+  autofill::SerializeFormData(form.form_data, pickle);
+}
+
 void NativeBackendKWalletPickleTest::CreateVersion1Pickle(
     const PasswordForm& form, Pickle* pickle) {
   pickle->WriteInt(1);
   CreatePickle(false, form, pickle);
 }
 
 void NativeBackendKWalletPickleTest::CreateVersion0Pickle(
     bool size_32, const PasswordForm& form, Pickle* pickle) {
   pickle->WriteInt(0);
   CreatePickle(size_32, form, pickle);
@@ skipping 12 matching lines @@
   pickle->WriteString16(form.username_value);
   pickle->WriteString16(form.password_element);
   pickle->WriteString16(form.password_value);
   pickle->WriteString16(form.submit_element);
   pickle->WriteBool(form.ssl_valid);
   pickle->WriteBool(form.preferred);
   pickle->WriteBool(form.blacklisted_by_user);
   pickle->WriteInt64(form.date_created.ToTimeT());
 }
 
-void NativeBackendKWalletPickleTest::CheckVersion0Pickle(
-    bool size_32, PasswordForm::Scheme scheme) {
+void NativeBackendKWalletPickleTest::CheckVersion2Pickle() {
   Pickle pickle;
-  PasswordForm form = old_form_google_;
-  form.scheme = scheme;
-  CreateVersion0Pickle(size_32, form, &pickle);
+  PasswordForm form = form_google_;
+  form.date_synced = base::Time();
+  CreateVersion2Pickle(form, &pickle);
+
   std::vector<PasswordForm*> form_list;
   NativeBackendKWalletStub::DeserializeValue(form.signon_realm,
                                              pickle, &form_list);
+
+  // This will match |old_form_google_| because not all the fields present in
+  // |form_google_| will be deserialized.
   EXPECT_EQ(1u, form_list.size());
   if (form_list.size() > 0)
     CheckPasswordForm(form, *form_list[0]);
   STLDeleteElements(&form_list);
 }
 
 // Make sure that we can still read version 1 pickles.
 void NativeBackendKWalletPickleTest::CheckVersion1Pickle() {
   Pickle pickle;
   PasswordForm form = form_google_;
   CreateVersion1Pickle(form, &pickle);
 
   std::vector<PasswordForm*> form_list;
   NativeBackendKWalletStub::DeserializeValue(form.signon_realm,
                                              pickle, &form_list);
 
   // This will match |old_form_google_| because not all the fields present in
   // |form_google_| will be deserialized.
   EXPECT_EQ(1u, form_list.size());
   if (form_list.size() > 0)
     CheckPasswordForm(old_form_google_, *form_list[0]);
   STLDeleteElements(&form_list);
 }
 
+void NativeBackendKWalletPickleTest::CheckVersion0Pickle(
+    bool size_32, PasswordForm::Scheme scheme) {
+  Pickle pickle;
+  PasswordForm form = old_form_google_;
+  form.scheme = scheme;
+  CreateVersion0Pickle(size_32, form, &pickle);
+  std::vector<PasswordForm*> form_list;
+  NativeBackendKWalletStub::DeserializeValue(form.signon_realm,
+                                             pickle, &form_list);
+  EXPECT_EQ(1u, form_list.size());
+  if (form_list.size() > 0)
+    CheckPasswordForm(form, *form_list[0]);
+  STLDeleteElements(&form_list);
+}
+
 // We try both SCHEME_HTML and SCHEME_BASIC since the scheme is stored right
 // after the size in the pickle, so it's what gets read as part of the count
 // when reading 32-bit pickles on 64-bit systems. SCHEME_HTML is 0 (so we'll
 // detect errors later) while SCHEME_BASIC is 1 (so we'll detect it then). We
 // try both 32-bit and 64-bit pickles since only one will be the "other" size
 // for whatever architecture we're running on, but we want to make sure we can
 // read all combinations in any event.
 
 TEST_F(NativeBackendKWalletPickleTest, ReadsOld32BitHTMLPickles) {
   CheckVersion0Pickle(true, PasswordForm::SCHEME_HTML);
 }
 
 TEST_F(NativeBackendKWalletPickleTest, ReadsOld32BitHTTPPickles) {
   CheckVersion0Pickle(true, PasswordForm::SCHEME_BASIC);
 }
 
 TEST_F(NativeBackendKWalletPickleTest, ReadsOld64BitHTMLPickles) {
   CheckVersion0Pickle(false, PasswordForm::SCHEME_HTML);
 }
 
 TEST_F(NativeBackendKWalletPickleTest, ReadsOld64BitHTTPPickles) {
   CheckVersion0Pickle(false, PasswordForm::SCHEME_BASIC);
 }
 
 TEST_F(NativeBackendKWalletPickleTest, CheckVersion1Pickle) {
   CheckVersion1Pickle();
 }
+
+TEST_F(NativeBackendKWalletPickleTest, CheckVersion2Pickle) {
+  CheckVersion2Pickle();
+}