Pull the phone library directly. Delete old version.

chrome/browser/autofill/phone_number_i18n.cc

 // Copyright (c) 2011 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/autofill/phone_number_i18n.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_country.h"
-#include "third_party/libphonenumber/cpp/src/phonenumberutil.h"
+#define USE_GOOGLE_BASE
+#include "third_party/libphonenumber/src/phonenumbers/phonenumberutil.h"

[Ilya Sherman, 2011/11/29 22:36:31]

Hmm, I don't like that every Chromium client would need to remember to add this
#define.  How about creating a wrapper header, that does something like the
following?

#define USE_GOOGLE_BASE
#include "third_party/libphonenumber/src/phonenumbers/phonenumberutil.h"
#undef USE_GOOGLE_BASE

[GeorgeY, 2011/11/29 23:58:45]

Done.

 
 using i18n::phonenumbers::PhoneNumber;
 using i18n::phonenumbers::PhoneNumberUtil;
 
 namespace {
 
 std::string SanitizeLocaleCode(const std::string& locale_code) {
   if (locale_code.length() == 2)
     return locale_code;
 
@@ skipping 77 matching lines @@
   if (area_length > 0) {
     area_code = national_significant_number.substr(0, area_length);
     subscriber_number = national_significant_number.substr(area_length);
   } else {
     subscriber_number = national_significant_number;
   }
   *number = UTF8ToUTF16(subscriber_number);
   *city_code = UTF8ToUTF16(area_code);
   *country_code = string16();
 
-  PhoneNumberUtil::NormalizeDigitsOnly(&number_text);
+  phone_util->NormalizeDigitsOnly(&number_text);
   string16 normalized_number(UTF8ToUTF16(number_text));
   // Check if parsed number has country code and it was not inferred from the
   // locale.
   if (i18n_number->has_country_code()) {
     *country_code = UTF8ToUTF16(
          base::StringPrintf("%d", i18n_number->country_code()));
     if (normalized_number.length() <= national_significant_number.length() &&
         (normalized_number.length() < country_code->length() ||
         normalized_number.compare(0, country_code->length(), *country_code))) {
       country_code->clear();
@@ skipping 19 matching lines @@
   if (!autofill_i18n::ConstructPhoneNumber(
           country_code, city_code, number,
           locale,
           (country_code.empty() ?
               autofill_i18n::NATIONAL : autofill_i18n::INTERNATIONAL),
           &result)) {
     // Reconstruction failed - do not store phone.
     return string16();
   }
   std::string result_utf8(UTF16ToUTF8(result));
-  PhoneNumberUtil::NormalizeDigitsOnly(&result_utf8);
+  PhoneNumberUtil::GetInstance()->NormalizeDigitsOnly(&result_utf8);
   return UTF8ToUTF16(result_utf8);
 }
 
 bool ParsePhoneNumber(const string16& value,
                       const std::string& locale,
                       string16* country_code,
                       string16* city_code,
                       string16* number) {
   PhoneNumber i18n_number;
   return ParsePhoneNumberInternal(value, SanitizeLocaleCode(locale),
                                   country_code, city_code, number,
                                   &i18n_number);
 }
 
 bool ConstructPhoneNumber(const string16& country_code,
                           const string16& city_code,
                           const string16& number,
                           const std::string& locale,
                           FullPhoneFormat phone_format,
                           string16* whole_number) {
   DCHECK(whole_number);
 
   whole_number->clear();
 
   std::string normalized_number(UTF16ToUTF8(city_code));
   normalized_number.append(UTF16ToUTF8(number));
 
-  PhoneNumberUtil::NormalizeDigitsOnly(&normalized_number);
+  PhoneNumberUtil* phone_util = PhoneNumberUtil::GetInstance();
+
+  phone_util->NormalizeDigitsOnly(&normalized_number);
 
   int64 number_int = 0;
   if (!base::StringToInt64(normalized_number, &number_int) || !number_int)
     return false;
 
   PhoneNumber i18n_number;
   i18n_number.set_national_number(static_cast<uint64>(number_int));
 
-  PhoneNumberUtil* phone_util = PhoneNumberUtil::GetInstance();
-
   int country_int = phone_util->GetCountryCodeForRegion(
       SanitizeLocaleCode(locale));
   if (!country_code.empty() && !base::StringToInt(country_code, &country_int))
     return false;
   if (country_int)
     i18n_number.set_country_code(country_int);
 
   i18n::phonenumbers::PhoneNumberUtil::ValidationResult validation =
       phone_util->IsPossibleNumberWithReason(i18n_number);
   if (validation != i18n::phonenumbers::PhoneNumberUtil::IS_POSSIBLE)
@@ skipping 105 matching lines @@
   number_ = other.number_;
   locale_ = other.locale_;
   if (other.i18n_number_.get())
     i18n_number_.reset(new PhoneNumber(*other.i18n_number_));
 
   return *this;
 }
 
 }  // namespace autofill_i18n