Minor fixes in login_database.* and sql/statement.*

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 <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <limits>
+#include <map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/pickle.h"
 #include "base/stl_util.h"
@@ skipping 1029 matching lines @@
 bool LoginDatabase::DisableAutoSignInForAllLogins() {
   sql::Statement s(db_.GetCachedStatement(
       SQL_FROM_HERE, "UPDATE logins SET skip_zero_click = 1;"));
 
   return s.Run();
 }
 
 // static
 LoginDatabase::EncryptionResult LoginDatabase::InitPasswordFormFromStatement(
     PasswordForm* form,
-    sql::Statement& s) {
+    sql::Statement* s) {
   std::string encrypted_password;
-  s.ColumnBlobAsString(COLUMN_PASSWORD_VALUE, &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) {
     VLOG(0) << "Password decryption failed, encryption_result is "
             << encryption_result;
     return encryption_result;
   }
 
-  std::string tmp = s.ColumnString(COLUMN_ORIGIN_URL);
+  std::string tmp = s->ColumnString(COLUMN_ORIGIN_URL);
   form->origin = GURL(tmp);
-  tmp = s.ColumnString(COLUMN_ACTION_URL);
+  tmp = s->ColumnString(COLUMN_ACTION_URL);
   form->action = GURL(tmp);
-  form->username_element = s.ColumnString16(COLUMN_USERNAME_ELEMENT);
-  form->username_value = s.ColumnString16(COLUMN_USERNAME_VALUE);
-  form->password_element = s.ColumnString16(COLUMN_PASSWORD_ELEMENT);
+  form->username_element = s->ColumnString16(COLUMN_USERNAME_ELEMENT);
+  form->username_value = s->ColumnString16(COLUMN_USERNAME_VALUE);
+  form->password_element = s->ColumnString16(COLUMN_PASSWORD_ELEMENT);
   form->password_value = decrypted_password;
-  form->submit_element = s.ColumnString16(COLUMN_SUBMIT_ELEMENT);
-  tmp = s.ColumnString(COLUMN_SIGNON_REALM);
+  form->submit_element = s->ColumnString16(COLUMN_SUBMIT_ELEMENT);
+  tmp = s->ColumnString(COLUMN_SIGNON_REALM);
   form->signon_realm = tmp;
-  form->ssl_valid = (s.ColumnInt(COLUMN_SSL_VALID) > 0);
-  form->preferred = (s.ColumnInt(COLUMN_PREFERRED) > 0);
+  form->ssl_valid = (s->ColumnInt(COLUMN_SSL_VALID) > 0);
+  form->preferred = (s->ColumnInt(COLUMN_PREFERRED) > 0);
   form->date_created =
-      base::Time::FromInternalValue(s.ColumnInt64(COLUMN_DATE_CREATED));
-  form->blacklisted_by_user = (s.ColumnInt(COLUMN_BLACKLISTED_BY_USER) > 0);
-  int scheme_int = s.ColumnInt(COLUMN_SCHEME);
+      base::Time::FromInternalValue(s->ColumnInt64(COLUMN_DATE_CREATED));
+  form->blacklisted_by_user = (s->ColumnInt(COLUMN_BLACKLISTED_BY_USER) > 0);
+  int scheme_int = s->ColumnInt(COLUMN_SCHEME);
   DCHECK_LE(0, scheme_int);
   DCHECK_GE(PasswordForm::SCHEME_LAST, scheme_int);
   form->scheme = static_cast<PasswordForm::Scheme>(scheme_int);
-  int type_int = s.ColumnInt(COLUMN_PASSWORD_TYPE);
+  int type_int = s->ColumnInt(COLUMN_PASSWORD_TYPE);
   DCHECK(type_int >= 0 && type_int <= PasswordForm::TYPE_LAST) << type_int;
   form->type = static_cast<PasswordForm::Type>(type_int);
-  if (s.ColumnByteLength(COLUMN_POSSIBLE_USERNAMES)) {
+  if (s->ColumnByteLength(COLUMN_POSSIBLE_USERNAMES)) {
     base::Pickle pickle(
-        static_cast<const char*>(s.ColumnBlob(COLUMN_POSSIBLE_USERNAMES)),
-        s.ColumnByteLength(COLUMN_POSSIBLE_USERNAMES));
+        static_cast<const char*>(s->ColumnBlob(COLUMN_POSSIBLE_USERNAMES)),
+        s->ColumnByteLength(COLUMN_POSSIBLE_USERNAMES));
     form->other_possible_usernames = DeserializeVector(pickle);
   }
-  form->times_used = s.ColumnInt(COLUMN_TIMES_USED);
-  if (s.ColumnByteLength(COLUMN_FORM_DATA)) {
+  form->times_used = s->ColumnInt(COLUMN_TIMES_USED);
+  if (s->ColumnByteLength(COLUMN_FORM_DATA)) {
     base::Pickle form_data_pickle(
-        static_cast<const char*>(s.ColumnBlob(COLUMN_FORM_DATA)),
-        s.ColumnByteLength(COLUMN_FORM_DATA));
+        static_cast<const char*>(s->ColumnBlob(COLUMN_FORM_DATA)),
+        s->ColumnByteLength(COLUMN_FORM_DATA));
     base::PickleIterator form_data_iter(form_data_pickle);
     bool success =
         autofill::DeserializeFormData(&form_data_iter, &form->form_data);
     metrics_util::FormDeserializationStatus status =
         success ? metrics_util::LOGIN_DATABASE_SUCCESS
                 : metrics_util::LOGIN_DATABASE_FAILURE;
     metrics_util::LogFormDataDeserializationStatus(status);
   }
   form->date_synced =
-      base::Time::FromInternalValue(s.ColumnInt64(COLUMN_DATE_SYNCED));
-  form->display_name = s.ColumnString16(COLUMN_DISPLAY_NAME);
-  form->icon_url = GURL(s.ColumnString(COLUMN_ICON_URL));
+      base::Time::FromInternalValue(s->ColumnInt64(COLUMN_DATE_SYNCED));
+  form->display_name = s->ColumnString16(COLUMN_DISPLAY_NAME);
+  form->icon_url = GURL(s->ColumnString(COLUMN_ICON_URL));
   form->federation_origin =
-      url::Origin(GURL(s.ColumnString(COLUMN_FEDERATION_URL)));
-  form->skip_zero_click = (s.ColumnInt(COLUMN_SKIP_ZERO_CLICK) > 0);
+      url::Origin(GURL(s->ColumnString(COLUMN_FEDERATION_URL)));
+  form->skip_zero_click = (s->ColumnInt(COLUMN_SKIP_ZERO_CLICK) > 0);
   int generation_upload_status_int =
-      s.ColumnInt(COLUMN_GENERATION_UPLOAD_STATUS);
+      s->ColumnInt(COLUMN_GENERATION_UPLOAD_STATUS);
   DCHECK(generation_upload_status_int >= 0 &&
          generation_upload_status_int <= PasswordForm::UNKNOWN_STATUS);
   form->generation_upload_status =
       static_cast<PasswordForm::GenerationUploadStatus>(
           generation_upload_status_int);
   return ENCRYPTION_RESULT_SUCCESS;
 }
 
 bool LoginDatabase::GetLogins(
     const PasswordForm& form,
@@ skipping 183 matching lines @@
 bool LoginDatabase::StatementToForms(
     sql::Statement* statement,
     const autofill::PasswordForm* matched_form,
     ScopedVector<autofill::PasswordForm>* forms) {
   PSLDomainMatchMetric psl_domain_match_metric = PSL_DOMAIN_MATCH_NONE;
 
   forms->clear();
   while (statement->Step()) {
     std::unique_ptr<PasswordForm> new_form(new PasswordForm());
     EncryptionResult result =
-        InitPasswordFormFromStatement(new_form.get(), *statement);
+        InitPasswordFormFromStatement(new_form.get(), statement);
     if (result == ENCRYPTION_RESULT_SERVICE_FAILURE)
       return false;
     if (result == ENCRYPTION_RESULT_ITEM_FAILURE)
       continue;
     DCHECK_EQ(ENCRYPTION_RESULT_SUCCESS, result);
     if (matched_form && matched_form->signon_realm != new_form->signon_realm) {
       if (new_form->scheme != PasswordForm::SCHEME_HTML)
         continue;  // Ignore non-HTML matches.
 
       if (IsPublicSuffixDomainMatch(new_form->signon_realm,
@@ skipping 14 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