Remove support for variant info in chrome://settings/autofill

chrome/browser/ui/webui/options/autofill_options_handler.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 "chrome/browser/ui/webui/options/autofill_options_handler.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 135 matching lines @@
         component->SetString(kField, kPostalCodeField);
         break;
       case i18n::addressinput::STREET_ADDRESS:
         component->SetString(kField, kAddressLineField);
         break;
       case i18n::addressinput::ORGANIZATION:
         component->SetString(kField, kCompanyNameField);
         break;
       case i18n::addressinput::RECIPIENT:
         component->SetString(kField, kFullNameField);
-        component->SetString(
-            "placeholder",
-            l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_ADD_NAME));
         break;
     }
 
     switch (components[i].length_hint) {
       case AddressUiComponent::HINT_LONG:
         component->SetString(kLength, "long");
         break;
       case AddressUiComponent::HINT_SHORT:
         component->SetString(kLength, "short");
         break;
@@ skipping 30 matching lines @@
   GetAddressComponents(countries.front()->country_code(),
                        g_browser_process->GetApplicationLocale(),
                        default_country_components.get(),
                        &default_country_language_code);
   localized_strings->Set("autofillDefaultCountryComponents",
                          default_country_components.release());
   localized_strings->SetString("autofillDefaultCountryLanguageCode",
                                default_country_language_code);
 }
 
-// Get the multi-valued element for |type| and return it in |ListValue| form.
-// Buyer beware: the type of data affects whether GetRawInfo or GetInfo is used.
-void GetValueList(const AutofillProfile& profile,
-                  ServerFieldType type,
-                  scoped_ptr<base::ListValue>* list) {
-  list->reset(new base::ListValue);
-
-  std::vector<base::string16> values;
-  if (AutofillType(type).group() == autofill::NAME) {
-    profile.GetMultiInfo(
-        AutofillType(type), g_browser_process->GetApplicationLocale(), &values);
-  } else {
-    profile.GetRawMultiInfo(type, &values);
-  }
-
-  // |Get[Raw]MultiInfo()| always returns at least one, potentially empty, item.
-  if (values.size() == 1 && values.front().empty())
-    return;
-
-  for (size_t i = 0; i < values.size(); ++i) {
-    (*list)->Set(i, new base::StringValue(values[i]));
-  }
-}
-
-// Converts a ListValue of StringValues to a vector of string16s.
-void ListValueToStringVector(const base::ListValue& list,
-                             std::vector<base::string16>* output) {
-  output->resize(list.GetSize());
-  for (size_t i = 0; i < list.GetSize(); ++i) {
-    base::string16 value;
-    if (list.GetString(i, &value))
-      (*output)[i].swap(value);
-  }
-}
-
-// Pulls the phone number |index|, |phone_number_list|, and |country_code| from
-// the |args| input.
-void ExtractPhoneNumberInformation(const base::ListValue* args,
-                                   size_t* index,
-                                   const base::ListValue** phone_number_list,
-                                   std::string* country_code) {
-  // Retrieve index as a |double|, as that is how it comes across from
-  // JavaScript.
-  double number = 0.0;
-  if (!args->GetDouble(0, &number)) {
-    NOTREACHED();
-    return;
-  }
-  *index = number;
-
-  if (!args->GetList(1, phone_number_list)) {
-    NOTREACHED();
-    return;
-  }
-
-  if (!args->GetString(2, country_code)) {
-    NOTREACHED();
-    return;
-  }
-}
-
-// Searches the |list| for the value at |index|.  If this value is present
-// in any of the rest of the list, then the item (at |index|) is removed.
-// The comparison of phone number values is done on normalized versions of the
-// phone number values.
-void RemoveDuplicatePhoneNumberAtIndex(size_t index,
-                                       const std::string& country_code,
-                                       base::ListValue* list) {
-  base::string16 new_value;
-  if (!list->GetString(index, &new_value)) {
-    NOTREACHED() << "List should have a value at index " << index;
-    return;
-  }
-
-  bool is_duplicate = false;
-  std::string app_locale = g_browser_process->GetApplicationLocale();
-  for (size_t i = 0; i < list->GetSize() && !is_duplicate; ++i) {
-    if (i == index)
-      continue;
-
-    base::string16 existing_value;
-    if (!list->GetString(i, &existing_value)) {
-      NOTREACHED() << "List should have a value at index " << i;
-      continue;
-    }
-    is_duplicate = autofill::i18n::PhoneNumbersMatch(
-        new_value, existing_value, country_code, app_locale);
-  }
-
-  if (is_duplicate)
-    list->Remove(index, NULL);
-}
-
-scoped_ptr<base::ListValue> ValidatePhoneArguments(
-    const base::ListValue* args) {
-  size_t index = 0;
-  std::string country_code;
-  const base::ListValue* extracted_list = NULL;
-  ExtractPhoneNumberInformation(args, &index, &extracted_list, &country_code);
-
-  scoped_ptr<base::ListValue> list(extracted_list->DeepCopy());
-  RemoveDuplicatePhoneNumberAtIndex(index, country_code, list.get());
-  return list.Pass();
-}
-
 }  // namespace
 
 namespace options {
 
 AutofillOptionsHandler::AutofillOptionsHandler()
     : personal_data_(NULL), observer_(this) {
 }
 
 AutofillOptionsHandler::~AutofillOptionsHandler() {
   if (personal_data_)
@@ skipping 97 matching lines @@
       base::Bind(&AutofillOptionsHandler::LoadCreditCardEditor,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setAddress",
       base::Bind(&AutofillOptionsHandler::SetAddress, base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setCreditCard",
       base::Bind(&AutofillOptionsHandler::SetCreditCard,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
-      "validatePhoneNumbers",
-      base::Bind(&AutofillOptionsHandler::ValidatePhoneNumbers,
-                 base::Unretained(this)));
-  web_ui()->RegisterMessageCallback(
       "clearLocalCardCopy",
       base::Bind(&AutofillOptionsHandler::RemaskServerCard,
                  base::Unretained(this)));
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // PersonalDataManagerObserver implementation:
 void AutofillOptionsHandler::OnPersonalDataChanged() {
   LoadAutofillData();
   OnStateChanged();
 }
 
 void AutofillOptionsHandler::OnStateChanged() {
   web_ui()->CallJavascriptFunction(
       "AutofillOptions.walletIntegrationAvailableStateChanged",
       base::FundamentalValue(autofill::WalletIntegrationAvailableForProfile(
           Profile::FromWebUI(web_ui()))));
 }
 
 void AutofillOptionsHandler::SetAddressOverlayStrings(
     base::DictionaryValue* localized_strings) {
   localized_strings->SetString("autofillEditAddressTitle",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_EDIT_ADDRESS_CAPTION));
   localized_strings->SetString("autofillCountryLabel",
       l10n_util::GetStringUTF16(IDS_LIBADDRESSINPUT_COUNTRY_OR_REGION_LABEL));
   localized_strings->SetString("autofillPhoneLabel",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_PHONE));
   localized_strings->SetString("autofillEmailLabel",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_EMAIL));
-  localized_strings->SetString("autofillAddPhonePlaceholder",
-      l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_ADD_PHONE));
-  localized_strings->SetString("autofillAddEmailPlaceholder",
-      l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_ADD_EMAIL));
   SetCountryData(*personal_data_, localized_strings);
 }
 
 void AutofillOptionsHandler::SetCreditCardOverlayStrings(
     base::DictionaryValue* localized_strings) {
   localized_strings->SetString("autofillEditCreditCardTitle",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_EDIT_CREDITCARD_CAPTION));
   localized_strings->SetString("nameOnCardLabel",
       l10n_util::GetStringUTF16(IDS_AUTOFILL_FIELD_LABEL_NAME_ON_CARD));
   localized_strings->SetString("creditCardNumberLabel",
@@ skipping 154 matching lines @@
   int arg_counter = 0;
   std::string guid;
   if (!args->GetString(arg_counter++, &guid)) {
     NOTREACHED();
     return;
   }
 
   AutofillProfile profile(guid, kSettingsOrigin);
 
   base::string16 value;
-  const base::ListValue* list_value;
-  if (args->GetList(arg_counter++, &list_value)) {
-    std::vector<base::string16> values;
-    ListValueToStringVector(*list_value, &values);
+  if (args->GetString(arg_counter++, &value)) {
+    // TODO(estade): get rid of this vector wrapper.
+    std::vector<base::string16> values(1, value);
     AutofillProfile* old_profile = personal_data_->GetProfileByGUID(guid);
     profile.CopyAndUpdateNameList(values, old_profile,
                                   g_browser_process->GetApplicationLocale());
   }
 
   if (args->GetString(arg_counter++, &value))
     profile.SetRawInfo(autofill::COMPANY_NAME, value);
 
   if (args->GetString(arg_counter++, &value))
     profile.SetRawInfo(autofill::ADDRESS_HOME_STREET_ADDRESS, value);
 
   if (args->GetString(arg_counter++, &value))
     profile.SetRawInfo(autofill::ADDRESS_HOME_DEPENDENT_LOCALITY, value);
 
   if (args->GetString(arg_counter++, &value))
     profile.SetRawInfo(autofill::ADDRESS_HOME_CITY, value);
 
   if (args->GetString(arg_counter++, &value))
     profile.SetRawInfo(autofill::ADDRESS_HOME_STATE, value);
 
   if (args->GetString(arg_counter++, &value))
     profile.SetRawInfo(autofill::ADDRESS_HOME_ZIP, value);
 
   if (args->GetString(arg_counter++, &value))
     profile.SetRawInfo(autofill::ADDRESS_HOME_SORTING_CODE, value);
 
   if (args->GetString(arg_counter++, &value))
     profile.SetRawInfo(autofill::ADDRESS_HOME_COUNTRY, value);
 
-  if (args->GetList(arg_counter++, &list_value)) {
-    std::vector<base::string16> values;
-    ListValueToStringVector(*list_value, &values);
-    profile.SetRawMultiInfo(autofill::PHONE_HOME_WHOLE_NUMBER, values);
-  }
+  if (args->GetString(arg_counter++, &value))
+    profile.SetRawInfo(autofill::PHONE_HOME_WHOLE_NUMBER, value);
 
-  if (args->GetList(arg_counter++, &list_value)) {
-    std::vector<base::string16> values;
-    ListValueToStringVector(*list_value, &values);
-    profile.SetRawMultiInfo(autofill::EMAIL_ADDRESS, values);
-  }
+  if (args->GetString(arg_counter++, &value))
+    profile.SetRawInfo(autofill::EMAIL_ADDRESS, value);
 
   if (args->GetString(arg_counter++, &value))
     profile.set_language_code(base::UTF16ToUTF8(value));
 
   if (!base::IsValidGUID(profile.guid())) {
     profile.set_guid(base::GenerateGUID());
     personal_data_->AddProfile(profile);
   } else {
     personal_data_->UpdateProfile(profile);
   }
@@ skipping 25 matching lines @@
     credit_card.SetRawInfo(autofill::CREDIT_CARD_EXP_4_DIGIT_YEAR, value);
 
   if (!base::IsValidGUID(credit_card.guid())) {
     credit_card.set_guid(base::GenerateGUID());
     personal_data_->AddCreditCard(credit_card);
   } else {
     personal_data_->UpdateCreditCard(credit_card);
   }
 }
 
-void AutofillOptionsHandler::ValidatePhoneNumbers(const base::ListValue* args) {
-  if (!IsPersonalDataLoaded())
-    return;
-
-  scoped_ptr<base::ListValue> list_value = ValidatePhoneArguments(args);
-
-  web_ui()->CallJavascriptFunction(
-      "AutofillEditAddressOverlay.setValidatedPhoneNumbers", *list_value);
-}
-
 void AutofillOptionsHandler::RemaskServerCard(const base::ListValue* args) {
   std::string guid;
   if (!args->GetString(0, &guid)) {
     NOTREACHED();
     return;
   }
 
   personal_data_->ResetFullServerCard(guid);
 }
 
 bool AutofillOptionsHandler::IsPersonalDataLoaded() const {
   return personal_data_ && personal_data_->IsDataLoaded();
 }
 
 // static
 void AutofillOptionsHandler::AutofillProfileToDictionary(
     const autofill::AutofillProfile& profile,
     base::DictionaryValue* address) {
   address->SetString("guid", profile.guid());
-  scoped_ptr<base::ListValue> list;
-  GetValueList(profile, autofill::NAME_FULL, &list);
-  address->Set(kFullNameField, list.release());
+  address->SetString(
+      kFullNameField,
+      profile.GetInfo(AutofillType(autofill::NAME_FULL),
+                      g_browser_process->GetApplicationLocale()));
   address->SetString(kCompanyNameField,
                      profile.GetRawInfo(autofill::COMPANY_NAME));
   address->SetString(kAddressLineField,
                      profile.GetRawInfo(autofill::ADDRESS_HOME_STREET_ADDRESS));
   address->SetString(kCityField,
                      profile.GetRawInfo(autofill::ADDRESS_HOME_CITY));
   address->SetString(kStateField,
                      profile.GetRawInfo(autofill::ADDRESS_HOME_STATE));
   address->SetString(
       kDependentLocalityField,
       profile.GetRawInfo(autofill::ADDRESS_HOME_DEPENDENT_LOCALITY));
   address->SetString(kSortingCodeField,
                      profile.GetRawInfo(autofill::ADDRESS_HOME_SORTING_CODE));
   address->SetString(kPostalCodeField,
                      profile.GetRawInfo(autofill::ADDRESS_HOME_ZIP));
   address->SetString(kCountryField,
                      profile.GetRawInfo(autofill::ADDRESS_HOME_COUNTRY));
-  GetValueList(profile, autofill::PHONE_HOME_WHOLE_NUMBER, &list);
-  address->Set("phone", list.release());
-  GetValueList(profile, autofill::EMAIL_ADDRESS, &list);
-  address->Set("email", list.release());
+  address->SetString("phone",
+                     profile.GetRawInfo(autofill::PHONE_HOME_WHOLE_NUMBER));
+  address->SetString("email", profile.GetRawInfo(autofill::EMAIL_ADDRESS));
   address->SetString(kLanguageCode, profile.language_code());
 
   scoped_ptr<base::ListValue> components(new base::ListValue);
   GetAddressComponents(
       base::UTF16ToUTF8(profile.GetRawInfo(autofill::ADDRESS_HOME_COUNTRY)),
       profile.language_code(),
       components.get(),
       NULL);
   address->Set(kComponents, components.release());
 }
 
 }  // namespace options