Another performance improvement for phone library - at least +25% to previous cl (982ms for 100 i...

chrome/browser/autofill/phone_number.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.h"
 
 #include "base/basictypes.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 36 matching lines @@
   *this = number;
 }
 
 PhoneNumber::~PhoneNumber() {}
 
 PhoneNumber& PhoneNumber::operator=(const PhoneNumber& number) {
   if (this == &number)
     return *this;
   number_ = number.number_;
   phone_group_ = number.phone_group_;
-  ClearCachedNumbers();
+  cached_parsed_phone_ = number.cached_parsed_phone_;
   return *this;
 }
 
 void PhoneNumber::GetMatchingTypes(const string16& text,
                                    FieldTypeSet* matching_types) const {
   string16 stripped_text(text);
   StripPunctuation(&stripped_text);
 
-  if (!UpdateCacheIfNeeded())
+  if (!cached_parsed_phone_.ValidNumber())
     return;
 
-  if (IsNumber(stripped_text, cached_local_number_))
+  if (IsNumber(stripped_text, cached_parsed_phone_.GetNumber()))
     matching_types->insert(GetNumberType());
 
-  if (stripped_text == cached_city_code_)
+  if (stripped_text == cached_parsed_phone_.GetCityCode())
     matching_types->insert(GetCityCodeType());
 
-  if (stripped_text == cached_country_code_)
+  if (stripped_text == cached_parsed_phone_.GetCountryCode())
     matching_types->insert(GetCountryCodeType());
 
-  string16 city_and_local(cached_city_code_);
-  city_and_local.append(cached_local_number_);
+  string16 city_and_local(cached_parsed_phone_.GetCityCode());
+  city_and_local.append(cached_parsed_phone_.GetNumber());
   if (stripped_text == city_and_local)
     matching_types->insert(GetCityAndNumberType());
 
   // Whole number is compared to unfiltered text - it would be parsed for phone
   // comparision (e.g. 1-800-FLOWERS and 18003569377 are the same)
   if (IsWholeNumber(text))
     matching_types->insert(GetWholeNumberType());
 }
 
 void PhoneNumber::GetNonEmptyTypes(FieldTypeSet* non_empty_types) const {
   DCHECK(non_empty_types);
 
   if (number_.empty())
     return;
 
   non_empty_types->insert(GetWholeNumberType());
 
-  if (!UpdateCacheIfNeeded())
+  if (!cached_parsed_phone_.ValidNumber())
     return;
 
   non_empty_types->insert(GetNumberType());
 
-  if (!cached_city_code_.empty()) {
+  if (!cached_parsed_phone_.GetCityCode().empty()) {
     non_empty_types->insert(GetCityCodeType());
     non_empty_types->insert(GetCityAndNumberType());
   }
 
-  if (!cached_country_code_.empty())
+  if (!cached_parsed_phone_.GetCountryCode().empty())
     non_empty_types->insert(GetCountryCodeType());
 }
 
 string16 PhoneNumber::GetInfo(AutofillFieldType type) const {
   if (type == GetWholeNumberType())
     return number_;
-  if (!UpdateCacheIfNeeded())
+
+  if (!cached_parsed_phone_.ValidNumber())
     return string16();
 
   if (type == GetNumberType())
-    return cached_local_number_;
+    return cached_parsed_phone_.GetNumber();
 
   if (type == GetCityCodeType())
-    return cached_city_code_;
+    return cached_parsed_phone_.GetCityCode();
 
   if (type == GetCountryCodeType())
-    return cached_country_code_;
+    return cached_parsed_phone_.GetCountryCode();
 
-  string16 city_and_local(cached_city_code_);
-  city_and_local.append(cached_local_number_);
+  string16 city_and_local(cached_parsed_phone_.GetCityCode());
+  city_and_local.append(cached_parsed_phone_.GetNumber());
   if (type == GetCityAndNumberType())
     return city_and_local;
 
   return string16();
 }
 
 void PhoneNumber::SetInfo(AutofillFieldType type, const string16& value) {
   FieldTypeSubGroup subgroup = AutofillType(type).subgroup();
   FieldTypeGroup group = AutofillType(type).group();
   if (phone_group_ == AutofillType::NO_GROUP)
     phone_group_ = group;  // First call on empty phone - set the group.
-  ClearCachedNumbers();
   if (subgroup == AutofillType::PHONE_NUMBER) {
     // Should not be set directly.
     NOTREACHED();
   } else if (subgroup == AutofillType::PHONE_CITY_CODE) {
     // Should not be set directly.
     NOTREACHED();
   } else if (subgroup == AutofillType::PHONE_COUNTRY_CODE) {
     // Should not be set directly.
     NOTREACHED();
   } else if (subgroup == AutofillType::PHONE_CITY_AND_NUMBER ||
              subgroup == AutofillType::PHONE_WHOLE_NUMBER) {
     number_ = value;
+    cached_parsed_phone_ = autofill_i18n::PhoneObject(number_, locale_);
     StripPunctuation(&number_);
   } else {
     NOTREACHED();
   }
 }
 
 bool PhoneNumber::NormalizePhone() {
   // Empty number does not need normalization.
   if (number_.empty())
     return true;
 
-  ClearCachedNumbers();
-  number_ = autofill_i18n::NormalizePhoneNumber(number_, locale_);
+  number_ = cached_parsed_phone_.GetWholeNumber();
   return !number_.empty();
 }
 
 void PhoneNumber::set_locale(const std::string& locale) {
   locale_ = locale;
-  ClearCachedNumbers();
+  if (!number_.empty() && cached_parsed_phone_.GetLocale() != locale_)
+    cached_parsed_phone_ = autofill_i18n::PhoneObject(number_, locale_);
 }
 
 AutofillFieldType PhoneNumber::GetNumberType() const {
   if (phone_group_ == AutofillType::PHONE_HOME)
     return PHONE_HOME_NUMBER;
   else if (phone_group_ == AutofillType::PHONE_FAX)
     return PHONE_FAX_NUMBER;
   else
     NOTREACHED();
   return UNKNOWN_TYPE;
@@ skipping 81 matching lines @@
     return true;
   if (text.length() == kPrefixLength && StartsWith(number, text, true))
     return true;
   if (text.length() == kSuffixLength && EndsWith(number, text, true))
     return true;
 
   return false;
 }
 
 bool PhoneNumber::IsWholeNumber(const string16& text) const {
-  return autofill_i18n::ComparePhones(text, number_, locale_) ==
-         autofill_i18n::PHONES_EQUAL;
+  return cached_parsed_phone_.ComparePhones(text) ==
+      autofill_i18n::PHONES_EQUAL;
 }
 
 // Static.
 void PhoneNumber::StripPunctuation(string16* number) {
   RemoveChars(*number, kPhoneNumberSeparators, number);
 }
-
-void PhoneNumber::ClearCachedNumbers() const {
-  cached_country_code_.clear();
-  cached_city_code_.clear();
-  cached_local_number_.clear();
-}
-
-bool PhoneNumber::UpdateCacheIfNeeded() const {
-  if (cached_local_number_.empty() && !number_.empty()) {
-    return autofill_i18n::ParsePhoneNumber(
-        number_, locale_, &cached_country_code_, &cached_city_code_,
-        &cached_local_number_);
-  } else {
-    return true;
-  }
-}