components/autofill/core/common/password_form.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <ostream>
   6 #include <sstream>
   7
   8 #include "base/json/json_writer.h"
   9 #include "base/strings/string16.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/values.h"
  13 #include "components/autofill/core/common/password_form.h"
  14
  15 namespace autofill {
  16
  17 namespace {
  18
  19 // Serializes a PasswordForm to a JSON object. Used only for logging in tests.
  20 void PasswordFormToJSON(const PasswordForm& form,
  21                         base::DictionaryValue* target) {
  22   target->SetInteger("scheme", form.scheme);
  23   target->SetString("signon_realm", form.signon_realm);
  24   target->SetString("signon_realm", form.signon_realm);
  25   target->SetString("original_signon_realm", form.original_signon_realm);
  26   target->SetString("origin", form.origin.possibly_invalid_spec());
  27   target->SetString("action", form.action.possibly_invalid_spec());
  28   target->SetString("submit_element", form.submit_element);
  29   target->SetString("username_elem", form.username_element);
  30   target->SetBoolean("username_marked_by_site", form.username_marked_by_site);
  31   target->SetString("username_value", form.username_value);
  32   target->SetString("password_elem", form.password_element);
  33   target->SetString("password_value", form.password_value);
  34   target->SetString("new_password_element", form.new_password_element);
  35   target->SetString("new_password_value", form.new_password_value);
  36   target->SetBoolean("new_password_marked_by_site",
  37                      form.new_password_marked_by_site);
  38   target->SetString("other_possible_usernames",
  39                     JoinString(form.other_possible_usernames, '|'));
  40   target->SetBoolean("autocomplete_set", form.password_autocomplete_set);
  41   target->SetBoolean("blacklisted", form.blacklisted_by_user);
  42   target->SetBoolean("preferred", form.preferred);
  43   target->SetBoolean("ssl_valid", form.ssl_valid);
  44   target->SetDouble("date_created", form.date_created.ToDoubleT());
  45   target->SetDouble("date_synced", form.date_synced.ToDoubleT());
  46   target->SetInteger("type", form.type);
  47   target->SetInteger("times_used", form.times_used);
  48   std::ostringstream form_data_string_stream;
  49   form_data_string_stream << form.form_data;
  50   target->SetString("form_data", form_data_string_stream.str());
  51   target->SetInteger("generation_upload_status", form.generation_upload_status);
  52   target->SetString("display_name", form.display_name);
  53   target->SetString("avatar_url", form.avatar_url.possibly_invalid_spec());
  54   target->SetString("federation_url",
  55                     form.federation_url.possibly_invalid_spec());
  56   target->SetBoolean("skip_next_zero_click", form.skip_zero_click);
  57   std::ostringstream layout_string_stream;
  58   layout_string_stream << form.layout;
  59   target->SetString("layout", layout_string_stream.str());
  60   target->SetBoolean("was_parsed_using_autofill_predictions",
  61                      form.was_parsed_using_autofill_predictions);
  62 }
  63
  64 }  // namespace
  65
  66 PasswordForm::PasswordForm()
  67     : scheme(SCHEME_HTML),
  68       username_marked_by_site(false),
  69       password_autocomplete_set(true),
  70       new_password_marked_by_site(false),
  71       ssl_valid(false),
  72       preferred(false),
  73       blacklisted_by_user(false),
  74       type(TYPE_MANUAL),
  75       times_used(0),
  76       generation_upload_status(NO_SIGNAL_SENT),
  77       skip_zero_click(false),
  78       layout(Layout::LAYOUT_OTHER),
  79       was_parsed_using_autofill_predictions(false),
  80       is_alive(true) {
  81 }
  82
  83 PasswordForm::~PasswordForm() {
  84   CHECK(is_alive);
  85   is_alive = false;
  86 }
  87
  88 bool PasswordForm::IsPublicSuffixMatch() const {
  89   CHECK(is_alive);
  90   return !original_signon_realm.empty();
  91 }
  92
  93 bool PasswordForm::operator==(const PasswordForm& form) const {
  94   return scheme == form.scheme &&
  95       signon_realm == form.signon_realm &&
  96       original_signon_realm == form.original_signon_realm &&
  97       origin == form.origin &&
  98       action == form.action &&
  99       submit_element == form.submit_element &&
 100       username_element == form.username_element &&
 101       username_marked_by_site == form.username_marked_by_site &&
 102       username_value == form.username_value &&
 103       other_possible_usernames == form.other_possible_usernames &&
 104       password_element == form.password_element &&
 105       password_value == form.password_value &&
 106       password_autocomplete_set == form.password_autocomplete_set &&
 107       new_password_element == form.new_password_element &&
 108       new_password_marked_by_site == form.new_password_marked_by_site &&
 109       new_password_value == form.new_password_value &&
 110       ssl_valid == form.ssl_valid &&
 111       preferred == form.preferred &&
 112       date_created == form.date_created &&
 113       date_synced == form.date_synced &&
 114       blacklisted_by_user == form.blacklisted_by_user &&
 115       type == form.type &&
 116       times_used == form.times_used &&
 117       form_data.SameFormAs(form.form_data) &&
 118       generation_upload_status == form.generation_upload_status &&
 119       display_name == form.display_name &&
 120       avatar_url == form.avatar_url &&
 121       federation_url == form.federation_url &&
 122       skip_zero_click == form.skip_zero_click &&
 123       layout == form.layout &&
 124       was_parsed_using_autofill_predictions ==
 125           form.was_parsed_using_autofill_predictions;
 126 }
 127
 128 bool PasswordForm::operator!=(const PasswordForm& form) const {
 129   return !operator==(form);
 130 }
 131
 132 std::ostream& operator<<(std::ostream& os, PasswordForm::Layout layout) {
 133   switch (layout) {
 134     case PasswordForm::Layout::LAYOUT_OTHER:
 135       os << "LAYOUT_OTHER";
 136       break;
 137     case PasswordForm::Layout::LAYOUT_LOGIN_AND_SIGNUP:
 138       os << "LAYOUT_LOGIN_AND_SIGNUP";
 139       break;
 140   }
 141   return os;
 142 }
 143
 144 std::ostream& operator<<(std::ostream& os, const PasswordForm& form) {
 145   base::DictionaryValue form_json;
 146   PasswordFormToJSON(form, &form_json);
 147
 148   // Serialize the default PasswordForm, and remove values from the result that
 149   // are equal to this to make the results more concise.
 150   base::DictionaryValue default_form_json;
 151   PasswordFormToJSON(PasswordForm(), &default_form_json);
 152   for (base::DictionaryValue::Iterator it_default_key_values(default_form_json);
 153        !it_default_key_values.IsAtEnd(); it_default_key_values.Advance()) {
 154     const base::Value* actual_value;
 155     if (form_json.Get(it_default_key_values.key(), &actual_value) &&
 156         it_default_key_values.value().Equals(actual_value)) {
 157       form_json.Remove(it_default_key_values.key(), nullptr);
 158     }
 159   }
 160
 161   std::string form_as_string;
 162   base::JSONWriter::WriteWithOptions(
 163       form_json, base::JSONWriter::OPTIONS_PRETTY_PRINT, &form_as_string);
 164   base::TrimWhitespaceASCII(form_as_string, base::TRIM_ALL, &form_as_string);
 165   return os << "PasswordForm(" << form_as_string << ")";
 166 }
 167
 168 std::ostream& operator<<(std::ostream& os, PasswordForm* form) {
 169   return os << "&" << *form;
 170 }
 171
 172 }  // namespace autofill