rAc: update android test

components/autofill/content/browser/wallet/wallet_address.cc

 // Copyright 2013 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/autofill/content/browser/wallet/wallet_address.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_type.h"
+#include "components/autofill/core/browser/phone_number.h"
 #include "components/autofill/core/browser/state_names.h"
 
 namespace autofill {
 namespace wallet {
 
 // Server specified type for address with complete details.
 const char kFullAddress[] = "FULL";
 
 namespace {
 
@@ skipping 73 matching lines @@
 
 Address::Address(const AutofillProfile& profile)
     : country_name_code_(
           UTF16ToASCII(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))),
       recipient_name_(profile.GetRawInfo(NAME_FULL)),
       address_line_1_(profile.GetRawInfo(ADDRESS_HOME_LINE1)),
       address_line_2_(profile.GetRawInfo(ADDRESS_HOME_LINE2)),
       locality_name_(profile.GetRawInfo(ADDRESS_HOME_CITY)),
       postal_code_number_(profile.GetRawInfo(ADDRESS_HOME_ZIP)),
       phone_number_(profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER)),
+      phone_object_(phone_number_, country_name_code_),
       is_complete_address_(true) {
   state_names::GetNameAndAbbreviation(profile.GetRawInfo(ADDRESS_HOME_STATE),
                                       NULL,
                                       &administrative_area_name_);
   StringToUpperASCII(&administrative_area_name_);
 }
 
 Address::Address(const std::string& country_name_code,
                  const string16& recipient_name,
                  const string16& address_line_1,
                  const string16& address_line_2,
                  const string16& locality_name,
                  const string16& administrative_area_name,
                  const string16& postal_code_number,
                  const string16& phone_number,
                  const std::string& object_id)
     : country_name_code_(country_name_code),
       recipient_name_(recipient_name),
       address_line_1_(address_line_1),
       address_line_2_(address_line_2),
       locality_name_(locality_name),
       administrative_area_name_(administrative_area_name),
       postal_code_number_(postal_code_number),
       phone_number_(phone_number),
+      phone_object_(phone_number_, country_name_code_),

[aruslan, 2013/10/01 01:51:17]

We couldn't have any issues with the field declaration order, right? Otherwise,
phone_object_(phone_number, country_name_code) looks safer.

[Evan Stade, 2013/10/01 02:00:36]

I did this to match L108, and yes it's safe.

       object_id_(object_id),
-      is_complete_address_(true) {
-}
+      is_complete_address_(true) {}
 
 Address::~Address() {}
 
 // static
 scoped_ptr<Address> Address::CreateAddressWithID(
     const base::DictionaryValue& dictionary) {
   std::string object_id;
   if (!dictionary.GetString("id", &object_id)) {
     DLOG(ERROR) << "Response from Google Wallet missing object id";
     return scoped_ptr<Address>();
@@ skipping 111 matching lines @@
 
 string16 Address::DisplayNameDetail() const {
 #if defined(OS_ANDROID)
   // TODO(aruslan): improve this stub implementation.
   return address_line_1();
 #else
   return string16();
 #endif
 }
 
+string16 Address::DisplayPhoneNumber() const {
+  // Return a formatted phone number. Wallet doesn't store user formatting, so
+  // impose our own. phone_number() always includes a country code, so using
+  // PhoneObject to format it would result in an internationalized format. Since
+  // Wallet only supports the US right now, stick to national formatting.
+  return i18n::PhoneObject(phone_number(), country_name_code()).
+      GetNationallyFormattedNumber();
+}
+
 string16 Address::GetInfo(const AutofillType& type,
                           const std::string& app_locale) const {
   if (type.html_type() == HTML_TYPE_COUNTRY_CODE) {
     DCHECK(IsStringASCII(country_name_code()));
     return ASCIIToUTF16(country_name_code());
   } else if (type.html_type() == HTML_TYPE_STREET_ADDRESS) {
     base::string16 address = address_line_1();
     if (!address_line_2().empty())
       address += ASCIIToUTF16(", ") + address_line_2();
     return address;
@@ skipping 17 matching lines @@
 
     case ADDRESS_HOME_ZIP:
       return postal_code_number();
 
     case ADDRESS_HOME_COUNTRY: {
       AutofillCountry country(country_name_code(), app_locale);
       return country.name();
     }
 
     case PHONE_HOME_WHOLE_NUMBER:
-      return phone_number();
+      // Wallet doesn't store user phone number formatting, so just strip all
+      // formatting.
+      return phone_object_.GetWholeNumber();
 
     // TODO(estade): implement more.
     default:
       NOTREACHED();
       return string16();
   }
 }
 
 bool Address::EqualsIgnoreID(const Address& other) const {
   return country_name_code_ == other.country_name_code_ &&
@@ skipping 10 matching lines @@
 bool Address::operator==(const Address& other) const {
   return object_id_ == other.object_id_ && EqualsIgnoreID(other);
 }
 
 bool Address::operator!=(const Address& other) const {
   return !(*this == other);
 }
 
 }  // namespace wallet
 }  // namespace autofill