AutoFill: Aggregate profile data. Remove the AutoFill InfoBar.

chrome/browser/autofill/credit_card.cc

 // Copyright (c) 2010 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/credit_card.h"
 
 #include "app/l10n_util.h"
 #include "base/basictypes.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/autofill_type.h"
 #include "chrome/browser/autofill/field_types.h"
 #include "grit/generated_resources.h"
 
 static const string16 kCreditCardSeparators = ASCIIToUTF16(" -");
 static const char* kCreditCardObfuscationString = "************";
 
 static const AutoFillFieldType kAutoFillCreditCardTypes[] = {
   CREDIT_CARD_NAME,
   CREDIT_CARD_NUMBER,
   CREDIT_CARD_TYPE,
   CREDIT_CARD_EXP_MONTH,
   CREDIT_CARD_EXP_4_DIGIT_YEAR,
-  CREDIT_CARD_VERIFICATION_CODE,
 };
 
 static const int kAutoFillCreditCardLength =
     arraysize(kAutoFillCreditCardTypes);
 
 CreditCard::CreditCard(const string16& label, int unique_id)
     : expiration_month_(0),
       expiration_year_(0),
       label_(label),
       unique_id_(unique_id) {
@@ skipping 24 matching lines @@
     possible_types->insert(CREDIT_CARD_EXP_MONTH);
 
   if (Is2DigitExpirationYear(text))
     possible_types->insert(CREDIT_CARD_EXP_2_DIGIT_YEAR);
 
   if (Is4DigitExpirationYear(text))
     possible_types->insert(CREDIT_CARD_EXP_4_DIGIT_YEAR);
 
   if (IsCardType(text))
     possible_types->insert(CREDIT_CARD_TYPE);
+}
 
-  if (IsVerificationCode(text))
-    possible_types->insert(CREDIT_CARD_VERIFICATION_CODE);
+void CreditCard::GetAvailableFieldTypes(FieldTypeSet* available_types) const {
+  DCHECK(available_types);
+
+  if (!name_on_card().empty())
+    available_types->insert(CREDIT_CARD_NAME);
+
+  if (!ExpirationMonthAsString().empty())
+    available_types->insert(CREDIT_CARD_EXP_MONTH);
+
+  if (!Expiration2DigitYearAsString().empty())
+    available_types->insert(CREDIT_CARD_EXP_2_DIGIT_YEAR);
+
+  if (!Expiration4DigitYearAsString().empty())
+    available_types->insert(CREDIT_CARD_EXP_4_DIGIT_YEAR);
+
+  if (!type().empty())
+    available_types->insert(CREDIT_CARD_TYPE);
+
+  if (!number().empty())
+    available_types->insert(CREDIT_CARD_NUMBER);
 }
 
 void CreditCard::FindInfoMatches(const AutoFillType& type,
                                  const string16& info,
                                  std::vector<string16>* matched_text) const {
-  if (matched_text == NULL) {
-    DLOG(ERROR) << "NULL matched vector passed in";
-    return;
-  }
+  DCHECK(matched_text);
 
   string16 match;
   switch (type.field_type()) {
     case CREDIT_CARD_NUMBER: {
       // Because the credit card number is encrypted and we are not able to do
       // comparisons with it we will say that any field that is known to be a
       // credit card number field will match all credit card numbers.
       string16 text = GetPreviewText(AutoFillType(CREDIT_CARD_NUMBER));
       if (!text.empty())
         matched_text->push_back(text);
       break;
     }
 
     case CREDIT_CARD_VERIFICATION_CODE:
+      NOTREACHED();
       break;
 
     case UNKNOWN_TYPE:
       for (int i = 0; i < kAutoFillCreditCardLength; ++i) {
         if (FindInfoMatchesHelper(kAutoFillCreditCardTypes[i], info, &match))
           matched_text->push_back(match);
       }
       break;
 
     default:
@@ skipping 33 matching lines @@
       return string16();
     }
 
     case CREDIT_CARD_TYPE:
       return this->type();
 
     case CREDIT_CARD_NUMBER:
       return number();
 
     case CREDIT_CARD_VERIFICATION_CODE:
-      return verification_code();
+      NOTREACHED();
+      return string16();
 
     default:
       // ComputeDataPresentForArray will hit this repeatedly.
       return string16();
   }
 }
 
 string16 CreditCard::GetPreviewText(const AutoFillType& type) const {
   switch (type.field_type()) {
     case CREDIT_CARD_NUMBER:
       return last_four_digits();
 
     case CREDIT_CARD_VERIFICATION_CODE:
-      return ASCIIToUTF16("xxx");
+      NOTREACHED();
+      return string16();
 
     default:
       return GetFieldText(type);
   }
 }
 
 void CreditCard::SetInfo(const AutoFillType& type, const string16& value) {
   switch (type.field_type()) {
     case CREDIT_CARD_NAME:
       set_name_on_card(value);
@@ skipping 18 matching lines @@
       }
       set_number(value);
       // Update last four digits as well.
       if (value.length() > 4)
         set_last_four_digits(value.substr(value.length() - 4));
       else
         set_last_four_digits(string16());
     }  break;
 
     case CREDIT_CARD_VERIFICATION_CODE:
-      set_verification_code(value);
+      NOTREACHED();
       break;
 
     default:
       DLOG(ERROR) << "Attempting to set unknown info-type "
                   << type.field_type();
       break;
   }
 }
 
 string16 CreditCard::ObfuscatedNumber() const {
   if (number().empty())
     return string16();  // No CC number, means empty preview.
   string16 result(ASCIIToUTF16(kCreditCardObfuscationString));
   result.append(last_four_digits());
 
   return result;
 }
 
 string16 CreditCard::PreviewSummary() const {
   string16 preview;
   if (number().empty())
     return preview;  // No CC number, means empty preview.
   string16 obfuscated_cc_number = ObfuscatedNumber();
   if (!expiration_month() || !expiration_year())
-    return obfuscated_cc_number;  // no expiration date set
-  // TODO(georgey): internationalize date
+    return obfuscated_cc_number;  // No expiration date set.
+  // TODO(georgey): Internationalize date.
   string16 formatted_date(ExpirationMonthAsString());
   formatted_date.append(ASCIIToUTF16("/"));
   formatted_date.append(Expiration4DigitYearAsString());
 
   preview = l10n_util::GetStringFUTF16(
       IDS_CREDIT_CARD_NUMBER_PREVIEW_FORMAT,
       obfuscated_cc_number,
       formatted_date);
   return preview;
 }
 
 string16 CreditCard::LastFourDigits() const {
   static const size_t kNumLastDigits = 4;
 
   if (number().size() < kNumLastDigits)
     return string16();
 
   return number().substr(number().size() - kNumLastDigits, kNumLastDigits);
 }
 
 void CreditCard::operator=(const CreditCard& source) {
   number_ = source.number_;
   name_on_card_ = source.name_on_card_;
   type_ = source.type_;
-  verification_code_ = source.verification_code_;
   last_four_digits_ = source.last_four_digits_;
   expiration_month_ = source.expiration_month_;
   expiration_year_ = source.expiration_year_;
   label_ = source.label_;
   billing_address_ = source.billing_address_;
-  shipping_address_ = source.shipping_address_;
   unique_id_ = source.unique_id_;
 }
 
 bool CreditCard::operator==(const CreditCard& creditcard) const {
   // The following CreditCard field types are the only types we store in the
   // WebDB so far, so we're only concerned with matching these types in the
   // profile.
   const AutoFillFieldType types[] = { CREDIT_CARD_NAME,
                                       CREDIT_CARD_TYPE,
                                       CREDIT_CARD_NUMBER,
-                                      CREDIT_CARD_VERIFICATION_CODE,
                                       CREDIT_CARD_EXP_MONTH,
                                       CREDIT_CARD_EXP_4_DIGIT_YEAR };
 
   if (label_ != creditcard.label_ ||
       unique_id_ != creditcard.unique_id_ ||
-      billing_address_ != creditcard.billing_address_ ||
-      shipping_address_ != creditcard.shipping_address_) {
+      billing_address_ != creditcard.billing_address_) {
     return false;
   }
 
   for (size_t index = 0; index < arraysize(types); ++index) {
     if (GetFieldText(AutoFillType(types[index])) !=
         creditcard.GetFieldText(AutoFillType(types[index])))
       return false;
   }
 
   return true;
@@ skipping 83 matching lines @@
       (expiration_year < 2006 || expiration_year > 10000)) {
     return;
   }
 
   expiration_year_ = expiration_year;
 }
 
 bool CreditCard::FindInfoMatchesHelper(const AutoFillFieldType& field_type,
                                        const string16& info,
                                        string16* match) const {
-  if (match == NULL) {
-    DLOG(ERROR) << "NULL match string passed in";
-    return false;
-  }
+  DCHECK(match);
 
   match->clear();
   switch (field_type) {
     case CREDIT_CARD_NAME: {
       if (StartsWith(name_on_card(), info, false))
         *match = name_on_card();
       break;
     }
 
     case CREDIT_CARD_EXP_MONTH: {
@@ skipping 27 matching lines @@
       if (StartsWith(exp_date, info, true))
         *match = exp_date;
     }
 
     case CREDIT_CARD_TYPE: {
       string16 card_type(this->type());
       if (StartsWith(card_type, info, true))
         *match = card_type;
     }
 
-    case CREDIT_CARD_VERIFICATION_CODE: {
-      if (StartsWith(verification_code(), info, true))
-        *match = verification_code();
-    }
+    case CREDIT_CARD_VERIFICATION_CODE:
+      NOTREACHED();
+      break;
 
     default:
       break;
   }
   return !match->empty();
 }
 
 bool CreditCard::IsNameOnCard(const string16& text) const {
   return StringToLowerASCII(text) == StringToLowerASCII(name_on_card_);
 }
 
-bool CreditCard::IsVerificationCode(const string16& text) const {
-  return StringToLowerASCII(text) == StringToLowerASCII(verification_code_);
-}
-
 bool CreditCard::IsExpirationMonth(const string16& text) const {
   int month;
   if (!StringToInt(text, &month))
     return false;
 
   return expiration_month_ == month;
 }
 
 bool CreditCard::Is2DigitExpirationYear(const string16& text) const {
   int year;
@@ skipping 31 matching lines @@
 
 // So we can compare CreditCards with EXPECT_EQ().
 std::ostream& operator<<(std::ostream& os, const CreditCard& creditcard) {
   return os
       << UTF16ToUTF8(creditcard.Label())
       << " "
       << creditcard.unique_id()
       << " "
       << UTF16ToUTF8(creditcard.billing_address())
       << " "
-      << UTF16ToUTF8(creditcard.shipping_address())
-      << " "
       << UTF16ToUTF8(creditcard.GetFieldText(AutoFillType(CREDIT_CARD_NAME)))
       << " "
       << UTF16ToUTF8(creditcard.GetFieldText(AutoFillType(CREDIT_CARD_TYPE)))
       << " "
       << UTF16ToUTF8(creditcard.GetFieldText(AutoFillType(CREDIT_CARD_NUMBER)))
       << " "
       << UTF16ToUTF8(creditcard.GetFieldText(
-             AutoFillType(CREDIT_CARD_VERIFICATION_CODE)))
-      << " "
-      << UTF16ToUTF8(creditcard.GetFieldText(
              AutoFillType(CREDIT_CARD_EXP_MONTH)))
       << " "
       << UTF16ToUTF8(creditcard.GetFieldText(
              AutoFillType(CREDIT_CARD_EXP_4_DIGIT_YEAR)));
 }