components/autofill/core/browser/phone_number_i18n.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 "components/autofill/core/browser/phone_number_i18n.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/logging.h"
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/strings/stringprintf.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "components/autofill/core/browser/autofill_country.h"
  14 #include "third_party/libphonenumber/src/phonenumber_api.h"
  15
  16 using i18n::phonenumbers::PhoneNumber;
  17 using i18n::phonenumbers::PhoneNumberUtil;
  18
  19 namespace autofill {
  20
  21 namespace {
  22
  23 std::string SanitizeRegion(const std::string& region,
  24                            const std::string& app_locale) {
  25   if (region.length() == 2)
  26     return region;
  27
  28   return AutofillCountry::CountryCodeForLocale(app_locale);
  29 }
  30
  31 // Returns true if |phone_number| is valid.
  32 bool IsValidPhoneNumber(const PhoneNumber& phone_number) {
  33   PhoneNumberUtil* phone_util = PhoneNumberUtil::GetInstance();
  34   if (!phone_util->IsPossibleNumber(phone_number))
  35     return false;
  36
  37   // Verify that the number has a valid area code (that in some cases could be
  38   // empty) for the parsed country code.  Also verify that this is a valid
  39   // number (for example, in the US 1234567 is not valid, because numbers do not
  40   // start with 1).
  41   if (!phone_util->IsValidNumber(phone_number))
  42     return false;
  43
  44   return true;
  45 }
  46
  47 // Formats the given |number| as a human-readable string, and writes the result
  48 // into |formatted_number|.  Also, normalizes the formatted number, and writes
  49 // that result into |normalized_number|.  This function should only be called
  50 // with numbers already known to be valid, i.e. validation should be done prior
  51 // to calling this function.  Note that the |country_code|, which determines
  52 // whether to format in the national or in the international format, is passed
  53 // in explicitly, as |number| might have an implicit country code set, even
  54 // though the original input lacked a country code.
  55 void FormatValidatedNumber(const PhoneNumber& number,
  56                            const base::string16& country_code,
  57                            base::string16* formatted_number,
  58                            base::string16* normalized_number) {
  59   PhoneNumberUtil::PhoneNumberFormat format =
  60       country_code.empty() ?
  61       PhoneNumberUtil::NATIONAL :
  62       PhoneNumberUtil::INTERNATIONAL;
  63
  64   PhoneNumberUtil* phone_util = PhoneNumberUtil::GetInstance();
  65   std::string processed_number;
  66   phone_util->Format(number, format, &processed_number);
  67
  68   std::string region_code;
  69   phone_util->GetRegionCodeForNumber(number, &region_code);
  70
  71   // Drop the leading '+' for US numbers as some US sites can't handle the "+",
  72   // and in the US dialing "+1..." is the same as dialing "1...".
  73   std::string prefix;
  74   if (processed_number[0] == '+') {
  75     processed_number = processed_number.substr(1);
  76     if (region_code != "US")
  77       prefix = "+";
  78   }
  79
  80   if (formatted_number)
  81     *formatted_number = base::UTF8ToUTF16(prefix + processed_number);
  82
  83   if (normalized_number) {
  84     phone_util->NormalizeDigitsOnly(&processed_number);
  85     *normalized_number = base::UTF8ToUTF16(prefix + processed_number);
  86   }
  87 }
  88
  89 }  // namespace
  90
  91 namespace i18n {
  92
  93 // Parses the number stored in |value| as it should be interpreted in the given
  94 // |default_region|, and stores the results into the remaining arguments.
  95 // The |default_region| should be sanitized prior to calling this function.
  96 bool ParsePhoneNumber(const base::string16& value,
  97                       const std::string& default_region,
  98                       base::string16* country_code,
  99                       base::string16* city_code,
 100                       base::string16* number,
 101                       std::string* inferred_region,
 102                       PhoneNumber* i18n_number) {
 103   country_code->clear();
 104   city_code->clear();
 105   number->clear();
 106   *i18n_number = PhoneNumber();
 107
 108   std::string number_text(base::UTF16ToUTF8(value));
 109
 110   // Parse phone number based on the region.
 111   PhoneNumberUtil* phone_util = PhoneNumberUtil::GetInstance();
 112
 113   // The |default_region| should already be sanitized.
 114   DCHECK_EQ(2U, default_region.size());
 115   if (phone_util->ParseAndKeepRawInput(
 116           number_text, default_region, i18n_number) !=
 117       PhoneNumberUtil::NO_PARSING_ERROR) {
 118     return false;
 119   }
 120
 121   if (!IsValidPhoneNumber(*i18n_number))
 122     return false;
 123
 124   std::string national_significant_number;
 125   phone_util->GetNationalSignificantNumber(*i18n_number,
 126                                            &national_significant_number);
 127
 128   int area_length = phone_util->GetLengthOfGeographicalAreaCode(*i18n_number);
 129   int destination_length =
 130       phone_util->GetLengthOfNationalDestinationCode(*i18n_number);
 131   // Some phones have a destination code in lieu of area code: mobile operators
 132   // in Europe, toll and toll-free numbers in USA, etc. From our point of view
 133   // these two types of codes are the same.
 134   if (destination_length > area_length)
 135     area_length = destination_length;
 136
 137   std::string area_code;
 138   std::string subscriber_number;
 139   if (area_length > 0) {
 140     area_code = national_significant_number.substr(0, area_length);
 141     subscriber_number = national_significant_number.substr(area_length);
 142   } else {
 143     subscriber_number = national_significant_number;
 144   }
 145   *number = base::UTF8ToUTF16(subscriber_number);
 146   *city_code = base::UTF8ToUTF16(area_code);
 147
 148   // Check if parsed number has a country code that was not inferred from the
 149   // region.
 150   if (i18n_number->has_country_code() &&
 151       i18n_number->country_code_source() != PhoneNumber::FROM_DEFAULT_COUNTRY) {
 152     *country_code = base::UTF8ToUTF16(
 153         base::StringPrintf("%d", i18n_number->country_code()));
 154   }
 155
 156   // The region might be different from what we started with.
 157   phone_util->GetRegionCodeForNumber(*i18n_number, inferred_region);
 158
 159   return true;
 160 }
 161
 162 base::string16 NormalizePhoneNumber(const base::string16& value,
 163                                     const std::string& region) {
 164   DCHECK_EQ(2u, region.size());
 165   base::string16 country_code, unused_city_code, unused_number;
 166   std::string unused_region;
 167   PhoneNumber phone_number;
 168   if (!ParsePhoneNumber(value, region, &country_code, &unused_city_code,
 169                         &unused_number, &unused_region, &phone_number)) {
 170     return base::string16();  // Parsing failed - do not store phone.
 171   }
 172
 173   base::string16 normalized_number;
 174   FormatValidatedNumber(phone_number, country_code, NULL, &normalized_number);
 175   return normalized_number;
 176 }
 177
 178 bool ConstructPhoneNumber(const base::string16& country_code,
 179                           const base::string16& city_code,
 180                           const base::string16& number,
 181                           const std::string& region,
 182                           base::string16* whole_number) {
 183   DCHECK_EQ(2u, region.size());
 184   whole_number->clear();
 185
 186   base::string16 unused_country_code, unused_city_code, unused_number;
 187   std::string unused_region;
 188   PhoneNumber phone_number;
 189   if (!ParsePhoneNumber(country_code + city_code + number, region,
 190                         &unused_country_code, &unused_city_code, &unused_number,
 191                         &unused_region, &phone_number)) {
 192     return false;
 193   }
 194
 195   FormatValidatedNumber(phone_number, country_code, whole_number, NULL);
 196   return true;
 197 }
 198
 199 bool PhoneNumbersMatch(const base::string16& number_a,
 200                        const base::string16& number_b,
 201                        const std::string& raw_region,
 202                        const std::string& app_locale) {
 203   // Sanitize the provided |raw_region| before trying to use it for parsing.
 204   const std::string region = SanitizeRegion(raw_region, app_locale);
 205
 206   PhoneNumberUtil* phone_util = PhoneNumberUtil::GetInstance();
 207
 208   // Parse phone numbers based on the region
 209   PhoneNumber i18n_number1;
 210   if (phone_util->Parse(
 211           base::UTF16ToUTF8(number_a), region.c_str(), &i18n_number1) !=
 212               PhoneNumberUtil::NO_PARSING_ERROR) {
 213     return false;
 214   }
 215
 216   PhoneNumber i18n_number2;
 217   if (phone_util->Parse(
 218           base::UTF16ToUTF8(number_b), region.c_str(), &i18n_number2) !=
 219               PhoneNumberUtil::NO_PARSING_ERROR) {
 220     return false;
 221   }
 222
 223   switch (phone_util->IsNumberMatch(i18n_number1, i18n_number2)) {
 224     case PhoneNumberUtil::INVALID_NUMBER:
 225     case PhoneNumberUtil::NO_MATCH:
 226       return false;
 227     case PhoneNumberUtil::SHORT_NSN_MATCH:
 228       return false;
 229     case PhoneNumberUtil::NSN_MATCH:
 230     case PhoneNumberUtil::EXACT_MATCH:
 231       return true;
 232   }
 233
 234   NOTREACHED();
 235   return false;
 236 }
 237
 238 PhoneObject::PhoneObject(const base::string16& number,
 239                          const std::string& region) {
 240   DCHECK_EQ(2u, region.size());
 241   // TODO(isherman): Autofill profiles should always have a |region| set, but in
 242   // some cases it should be marked as implicit.  Otherwise, phone numbers
 243   // might behave differently when they are synced across computers:
 244   // [ http://crbug.com/100845 ].  Once the bug is fixed, add a DCHECK here to
 245   // verify.
 246
 247   scoped_ptr<PhoneNumber> i18n_number(new PhoneNumber);
 248   if (ParsePhoneNumber(number, region, &country_code_, &city_code_, &number_,
 249                        &region_, i18n_number.get())) {
 250     // The phone number was successfully parsed, so store the parsed version.
 251     // The formatted and normalized versions will be set on the first call to
 252     // the coresponding methods.
 253     i18n_number_ = i18n_number.Pass();
 254   } else {
 255     // Parsing failed. Store passed phone "as is" into |whole_number_|.
 256     whole_number_ = number;
 257   }
 258 }
 259
 260 PhoneObject::PhoneObject(const PhoneObject& other) { *this = other; }
 261
 262 PhoneObject::PhoneObject() {}
 263
 264 PhoneObject::~PhoneObject() {}
 265
 266 const base::string16& PhoneObject::GetFormattedNumber() const {
 267   if (i18n_number_ && formatted_number_.empty()) {
 268     FormatValidatedNumber(*i18n_number_, country_code_, &formatted_number_,
 269                           &whole_number_);
 270   }
 271
 272   return formatted_number_;
 273 }
 274
 275 base::string16 PhoneObject::GetNationallyFormattedNumber() const {
 276   base::string16 formatted = whole_number_;
 277   if (i18n_number_)
 278     FormatValidatedNumber(*i18n_number_, base::string16(), &formatted, NULL);
 279
 280   return formatted;
 281 }
 282
 283 const base::string16& PhoneObject::GetWholeNumber() const {
 284   if (i18n_number_ && whole_number_.empty()) {
 285     FormatValidatedNumber(*i18n_number_, country_code_, &formatted_number_,
 286                           &whole_number_);
 287   }
 288
 289   return whole_number_;
 290 }
 291
 292 PhoneObject& PhoneObject::operator=(const PhoneObject& other) {
 293   if (this == &other)
 294     return *this;
 295
 296   region_ = other.region_;
 297
 298   if (other.i18n_number_.get())
 299     i18n_number_.reset(new PhoneNumber(*other.i18n_number_));
 300   else
 301     i18n_number_.reset();
 302
 303   country_code_ = other.country_code_;
 304   city_code_ = other.city_code_;
 305   number_ = other.number_;
 306
 307   formatted_number_ = other.formatted_number_;
 308   whole_number_ = other.whole_number_;
 309
 310   return *this;
 311 }
 312
 313 }  // namespace i18n
 314 }  // namespace autofill