[Password manager IOS upsteaming] Upstreaming login database

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"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/pickle.h"
+#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/password_manager/core/browser/affiliation_utils.h"
 #include "components/password_manager/core/browser/password_manager_client.h"
 #include "components/password_manager/core/browser/password_manager_metrics_util.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "sql/connection.h"
@@ skipping 569 matching lines @@
   return list;
 }
 
 PasswordStoreChangeList LoginDatabase::UpdateLogin(const PasswordForm& form) {
   std::string encrypted_password;
   if (EncryptedString(
           clear_password_values_ ? base::string16() : form.password_value,
           &encrypted_password) != ENCRYPTION_RESULT_SUCCESS)
     return PasswordStoreChangeList();
 
+#if defined(OS_IOS)
+  DeleteEncryptedPassword(form);
+#endif
   // 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 = ?, "
@@ skipping 44 matching lines @@
     return PasswordStoreChangeList();
 
   PasswordStoreChangeList list;
   if (db_.GetLastChangeCount())
     list.push_back(PasswordStoreChange(PasswordStoreChange::UPDATE, form));
 
   return list;
 }
 
 bool LoginDatabase::RemoveLogin(const PasswordForm& form) {
+#if defined(OS_IOS)
+  DeleteEncryptedPassword(form);
+#endif
   if (form.IsPublicSuffixMatch()) {
     // Do not try to remove |form|. It is a modified copy of a password stored
     // for a different origin, and it is not contained in the database.
     return false;
   }
   // Remove a login by UNIQUE-constrained fields.
   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
                                           "DELETE FROM logins WHERE "
                                           "origin_url = ? AND "
                                           "username_element = ? AND "
                                           "username_value = ? AND "
                                           "password_element = ? AND "
                                           "submit_element = ? AND "
                                           "signon_realm = ? "));
   s.BindString(0, form.origin.spec());
   s.BindString16(1, form.username_element);
   s.BindString16(2, form.username_value);
   s.BindString16(3, form.password_element);
   s.BindString16(4, form.submit_element);
   s.BindString(5, form.signon_realm);
 
   return s.Run() && db_.GetLastChangeCount() > 0;
 }
 
 bool LoginDatabase::RemoveLoginsCreatedBetween(base::Time delete_begin,
                                                base::Time delete_end) {
+#if defined(OS_IOS)
+  ScopedVector<autofill::PasswordForm> forms;
+  if (GetLoginsCreatedBetween(delete_begin, delete_end, &forms)) {
+    for (size_t i = 0; i < forms.size(); i++) {
+      DeleteEncryptedPassword(*forms[i]);
+    }
+  }
+#endif
+
   sql::Statement s(db_.GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM logins WHERE "
       "date_created >= ? AND date_created < ?"));
   s.BindInt64(0, delete_begin.ToInternalValue());
   s.BindInt64(1, delete_end.is_null() ? std::numeric_limits<int64>::max()
                                       : delete_end.ToInternalValue());
 
   return s.Run();
 }
 
@@ skipping 218 matching lines @@
 }
 
 bool LoginDatabase::DeleteAndRecreateDatabaseFile() {
   DCHECK(db_.is_open());
   meta_table_.Reset();
   db_.Close();
   sql::Connection::Delete(db_path_);
   return Init();
 }
 
+std::string LoginDatabase::GetEncryptedPassword(
+    const autofill::PasswordForm& form) const {
+  sql::Statement s(
+      db_.GetCachedStatement(SQL_FROM_HERE,
+                             "SELECT password_value FROM logins WHERE "
+                             "origin_url = ? AND "
+                             "username_element = ? AND "
+                             "username_value = ? AND "
+                             "password_element = ? AND "
+                             "submit_element = ? AND "
+                             "signon_realm = ? "));
+
+  s.BindString(0, form.origin.spec());
+  s.BindString16(1, form.username_element);
+  s.BindString16(2, form.username_value);
+  s.BindString16(3, form.password_element);
+  s.BindString16(4, form.submit_element);
+  s.BindString(5, form.signon_realm);
+
+  std::string encrypted_password;
+  if (s.Step()) {
+    s.ColumnBlobAsString(0, &encrypted_password);
+  }
+  return encrypted_password;
+}
+
 // static
 bool LoginDatabase::StatementToForms(
     sql::Statement* statement,
     const autofill::PasswordForm* psl_match,
     ScopedVector<autofill::PasswordForm>* forms) {
   PSLDomainMatchMetric psl_domain_match_metric = PSL_DOMAIN_MATCH_NONE;
 
   forms->clear();
   while (statement->Step()) {
     scoped_ptr<PasswordForm> new_form(new PasswordForm());
@@ skipping 32 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("PasswordManager.PslDomainMatchTriggering",
                               psl_domain_match_metric, PSL_DOMAIN_MATCH_COUNT);
   }
 
   if (!statement->Succeeded())
     return false;
   return true;
 }
 
 }  // namespace password_manager