Support to remove passwords by date_synced timestamp.

components/password_manager/core/browser/login_database.cc

 // Copyright 2014 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 "components/password_manager/core/browser/login_database.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 336 matching lines @@
 
 PasswordStoreChangeList LoginDatabase::UpdateLogin(const PasswordForm& form) {
   std::string encrypted_password;
   if (EncryptedString(form.password_value, &encrypted_password) !=
           ENCRYPTION_RESULT_SUCCESS)
     return PasswordStoreChangeList();
 
   // Replacement is necessary to deal with updating imported credentials. See
   // crbug.com/349138 for details.
   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
-      "UPDATE OR REPLACE logins SET "
-      "action_url = ?, "
-      "password_value = ?, "
-      "ssl_valid = ?, "
-      "preferred = ?, "
-      "possible_usernames = ?, "
-      "times_used = ?, "
-      "submit_element = ? "
-      "WHERE origin_url = ? AND "
-      "username_element = ? AND "
-      "username_value = ? AND "
-      "password_element = ? AND "
-      "signon_realm = ?"));
+                                          "UPDATE OR REPLACE logins SET "
+                                          "action_url = ?, "
+                                          "password_value = ?, "
+                                          "ssl_valid = ?, "
+                                          "preferred = ?, "
+                                          "possible_usernames = ?, "
+                                          "times_used = ?, "
+                                          "submit_element = ?, "
+                                          "date_synced = ? "
+                                          "WHERE origin_url = ? AND "
+                                          "username_element = ? AND "
+                                          "username_value = ? AND "
+                                          "password_element = ? AND "
+                                          "signon_realm = ?"));
   s.BindString(0, form.action.spec());
   s.BindBlob(1, encrypted_password.data(),
              static_cast<int>(encrypted_password.length()));
   s.BindInt(2, form.ssl_valid);
   s.BindInt(3, form.preferred);
   Pickle pickle = SerializeVector(form.other_possible_usernames);
   s.BindBlob(4, pickle.data(), pickle.size());
   s.BindInt(5, form.times_used);
   s.BindString16(6, form.submit_element);
+  s.BindInt64(7, form.date_synced.ToInternalValue());
 
-  s.BindString(7, form.origin.spec());
-  s.BindString16(8, form.username_element);
-  s.BindString16(9, form.username_value);
-  s.BindString16(10, form.password_element);
-  s.BindString(11, form.signon_realm);
+  s.BindString(8, form.origin.spec());
+  s.BindString16(9, form.username_element);
+  s.BindString16(10, form.username_value);
+  s.BindString16(11, form.password_element);
+  s.BindString(12, form.signon_realm);
 
   if (!s.Run())
     return PasswordStoreChangeList();
 
   PasswordStoreChangeList list;
   if (db_.GetLastChangeCount())
     list.push_back(PasswordStoreChange(PasswordStoreChange::UPDATE, form));
 
   return list;
 }
@@ skipping 23 matching lines @@
   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM logins WHERE "
       "date_created >= ? AND date_created < ?"));
   s.BindInt64(0, delete_begin.ToTimeT());
   s.BindInt64(1, delete_end.is_null() ? std::numeric_limits<int64>::max()
                                       : delete_end.ToTimeT());
 
   return s.Run();
 }
 
+bool LoginDatabase::RemoveLoginsSyncedBetween(base::Time delete_begin,
+                                              base::Time delete_end) {
+  sql::Statement s(db_.GetCachedStatement(
+      SQL_FROM_HERE,
+      "DELETE FROM logins WHERE date_synced >= ? AND date_synced < ?"));
+  s.BindInt64(0, delete_begin.ToInternalValue());
+  s.BindInt64(1,
+              delete_end.is_null() ? base::Time::Max().ToInternalValue()
+                                   : delete_end.ToInternalValue());
+
+  return s.Run();
+}
+
 LoginDatabase::EncryptionResult LoginDatabase::InitPasswordFormFromStatement(
     PasswordForm* form,
     sql::Statement& s) const {
   std::string encrypted_password;
   s.ColumnBlobAsString(COLUMN_PASSWORD_VALUE, &encrypted_password);
   base::string16 decrypted_password;
   EncryptionResult encryption_result =
       DecryptedString(encrypted_password, &decrypted_password);
   if (encryption_result != ENCRYPTION_RESULT_SUCCESS)
     return encryption_result;
@@ skipping 158 matching lines @@
     if (result == ENCRYPTION_RESULT_SERVICE_FAILURE)
       return false;
     if (result == ENCRYPTION_RESULT_ITEM_FAILURE)
       continue;
     DCHECK(result == ENCRYPTION_RESULT_SUCCESS);
     forms->push_back(new_form.release());
   }
   return s.Succeeded();
 }
 
+bool LoginDatabase::GetLoginsSyncedBetween(
+    const base::Time begin,
+    const base::Time end,
+    std::vector<autofill::PasswordForm*>* forms) const {
+  DCHECK(forms);
+  sql::Statement s(db_.GetCachedStatement(
+      SQL_FROM_HERE,
+      "SELECT origin_url, action_url, username_element, username_value, "
+      "password_element, password_value, submit_element, signon_realm, "
+      "ssl_valid, preferred, date_created, blacklisted_by_user, "
+      "scheme, password_type, possible_usernames, times_used, form_data, "
+      "use_additional_auth, date_synced FROM logins "
+      "WHERE date_synced >= ? AND date_synced < ?"
+      "ORDER BY origin_url"));
+  s.BindInt64(0, begin.ToInternalValue());
+  s.BindInt64(1,
+              end.is_null() ? base::Time::Max().ToInternalValue()
+                            : end.ToInternalValue());
+
+  while (s.Step()) {
+    scoped_ptr<PasswordForm> new_form(new PasswordForm());
+    EncryptionResult result = InitPasswordFormFromStatement(new_form.get(), s);
+    if (result == ENCRYPTION_RESULT_SERVICE_FAILURE)
+      return false;
+    if (result == ENCRYPTION_RESULT_ITEM_FAILURE)
+      continue;
+    DCHECK(result == ENCRYPTION_RESULT_SUCCESS);
+    forms->push_back(new_form.release());
+  }
+  return s.Succeeded();
+}
+
 bool LoginDatabase::GetAutofillableLogins(
     std::vector<PasswordForm*>* forms) const {
   return GetAllLoginsWithBlacklistSetting(false, forms);
 }
 
 bool LoginDatabase::GetBlacklistLogins(
     std::vector<PasswordForm*>* forms) const {
   return GetAllLoginsWithBlacklistSetting(true, forms);
 }
 
@@ skipping 26 matching lines @@
 
 bool LoginDatabase::DeleteAndRecreateDatabaseFile() {
   DCHECK(db_.is_open());
   meta_table_.Reset();
   db_.Close();
   sql::Connection::Delete(db_path_);
   return Init(db_path_);
 }
 
 }  // namespace password_manager