Support to remove passwords by date_synced timestamp.

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 153 matching lines @@
     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);
+  static void CheckPasswordChangesWithResult(
+      const PasswordStoreChangeList* expected,
+      const PasswordStoreChangeList* actual,
+      bool result);
 
   PasswordForm old_form_google_;
   PasswordForm form_google_;
   PasswordForm form_isc_;
 };
 
+// static
 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);
 }
 
+// static
 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());
   }
 }
 
+// static
+void NativeBackendKWalletTestBase::CheckPasswordChangesWithResult(
+    const PasswordStoreChangeList* expected,
+    const PasswordStoreChangeList* actual,
+    bool result) {
+  EXPECT_TRUE(result);
+  CheckPasswordChanges(*expected, *actual);
+}
+
 class NativeBackendKWalletTest : public NativeBackendKWalletTestBase {
  protected:
   NativeBackendKWalletTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         db_thread_(BrowserThread::DB), klauncher_ret_(0),
         klauncher_contacted_(false), kwallet_runnable_(true),
         kwallet_running_(true), kwallet_enabled_(true) {
   }
 
   virtual void SetUp();
@@ skipping 565 matching lines @@
 
   EXPECT_FALSE(wallet_.hasFolder("Chrome Form Data"));
 
   std::vector<const PasswordForm*> forms;
   forms.push_back(&form_google_);
   ExpectationArray expected;
   expected.push_back(make_pair(std::string(form_google_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
+TEST_F(NativeBackendKWalletTest, RemoveLoginsSyncedBetween) {
+  NativeBackendKWalletStub backend(42);
+  EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
+
+  base::Time now = base::Time::Now();
+  base::Time next_day = now + base::TimeDelta::FromDays(1);
+  form_google_.date_synced = now;
+  form_isc_.date_synced = next_day;
+  form_google_.date_created = base::Time();
+  form_isc_.date_created = base::Time();
+
+  BrowserThread::PostTask(
+      BrowserThread::DB, FROM_HERE,
+      base::Bind(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
+                 base::Unretained(&backend), form_google_));
+  BrowserThread::PostTask(
+      BrowserThread::DB, FROM_HERE,
+      base::Bind(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
+                 base::Unretained(&backend), form_isc_));
+
+  PasswordStoreChangeList expected_changes;
+  expected_changes.push_back(PasswordStoreChange(PasswordStoreChange::REMOVE,
+                                                 form_google_));
+  PasswordStoreChangeList changes;
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::DB, FROM_HERE,
+      base::Bind(&NativeBackendKWalletStub::RemoveLoginsSyncedBetween,
+                 base::Unretained(&backend), base::Time(), next_day, &changes),
+      base::Bind(&NativeBackendKWalletTest::CheckPasswordChangesWithResult,
+                 &expected_changes, &changes));
+  RunDBThread();
+
+  std::vector<const PasswordForm*> forms;
+  forms.push_back(&form_isc_);
+  ExpectationArray expected;
+  expected.push_back(make_pair(std::string(form_isc_.signon_realm), forms));
+  CheckPasswordForms("Chrome Form Data (42)", expected);
+
+  // Remove form_isc_.
+  expected_changes.clear();
+  expected_changes.push_back(PasswordStoreChange(PasswordStoreChange::REMOVE,
+                                                 form_isc_));
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::DB, FROM_HERE,
+      base::Bind(&NativeBackendKWalletStub::RemoveLoginsSyncedBetween,
+                 base::Unretained(&backend), next_day, base::Time(), &changes),
+      base::Bind(&NativeBackendKWalletTest::CheckPasswordChangesWithResult,
+                 &expected_changes, &changes));
+  RunDBThread();
+
+  CheckPasswordForms("Chrome Form Data (42)", ExpectationArray());
+}
+
 // 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);
@@ skipping 121 matching lines @@
   CheckVersion0Pickle(false, PasswordForm::SCHEME_BASIC);
 }
 
 TEST_F(NativeBackendKWalletPickleTest, CheckVersion1Pickle) {
   CheckVersion1Pickle();
 }
 
 TEST_F(NativeBackendKWalletPickleTest, CheckVersion2Pickle) {
   CheckVersion2Pickle();
 }