[Autofill] Update user-facing strings for server cards

components/autofill/content/browser/wallet/wallet_items.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_items.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 110 matching lines @@
 WalletItems::MaskedInstrument::~MaskedInstrument() {}
 
 scoped_ptr<WalletItems::MaskedInstrument>
     WalletItems::MaskedInstrument::CreateMaskedInstrument(
     const base::DictionaryValue& dictionary) {
   std::string type_string;
   Type type;
   if (dictionary.GetString("type", &type_string)) {
     type = TypeFromString(type_string);
   } else {
-    DLOG(ERROR) << "Response from Google Wallet missing card type";
+    DLOG(ERROR) << "Response from Google Payments missing card type";

[Evan Stade, 2015/05/29 19:34:26]

it is arguable whether these are user-facing but I think changing them is cheap.

[please use gerrit instead, 2015/05/29 19:37:52]

Acknowledged.

     return scoped_ptr<MaskedInstrument>();
   }
 
   base::string16 last_four_digits;
   if (!dictionary.GetString("last_four_digits", &last_four_digits)) {
-    DLOG(ERROR) << "Response from Google Wallet missing last four digits";
+    DLOG(ERROR) << "Response from Google Payments missing last four digits";
     return scoped_ptr<MaskedInstrument>();
   }
 
   std::string status_string;
   Status status;
   if (dictionary.GetString("status", &status_string)) {
     status = StatusFromString(status_string);
   } else {
-    DLOG(ERROR) << "Response from Google Wallet missing status";
+    DLOG(ERROR) << "Response from Google Payments missing status";
     return scoped_ptr<MaskedInstrument>();
   }
 
   std::string object_id;
   if (!dictionary.GetString("object_id", &object_id)) {
-    DLOG(ERROR) << "Response from Google Wallet missing object id";
+    DLOG(ERROR) << "Response from Google Payments missing object id";
     return scoped_ptr<MaskedInstrument>();
   }
 
   const base::DictionaryValue* address_dict;
   if (!dictionary.GetDictionary("billing_address", &address_dict)) {
     DLOG(ERROR) << "Response from Google wallet missing address";
     return scoped_ptr<MaskedInstrument>();
   }
   scoped_ptr<Address> address = Address::CreateDisplayAddress(*address_dict);
 
   if (!address) {
     DLOG(ERROR) << "Response from Google wallet contained malformed address";
     return scoped_ptr<MaskedInstrument>();
   }
 
   int expiration_month;
   if (!dictionary.GetInteger("expiration_month", &expiration_month))
-    DVLOG(1) << "Response from Google Wallet missing expiration month";
+    DVLOG(1) << "Response from Google Payments missing expiration month";
 
   int expiration_year;
   if (!dictionary.GetInteger("expiration_year", &expiration_year))
-    DVLOG(1) << "Response from Google Wallet missing expiration year";
+    DVLOG(1) << "Response from Google Payments missing expiration year";
 
   base::string16 descriptive_name;
   if (!dictionary.GetString("descriptive_name", &descriptive_name))
-    DVLOG(1) << "Response from Google Wallet missing descriptive name";
+    DVLOG(1) << "Response from Google Payments missing descriptive name";
 
   return scoped_ptr<MaskedInstrument>(new MaskedInstrument(descriptive_name,
                                                            type,
                                                            last_four_digits,
                                                            expiration_month,
                                                            expiration_year,
                                                            address.Pass(),
                                                            status,
                                                            object_id));
 }
@@ skipping 166 matching lines @@
   return base::string16();
 }
 
 WalletItems::LegalDocument::~LegalDocument() {}
 
 scoped_ptr<WalletItems::LegalDocument>
     WalletItems::LegalDocument::CreateLegalDocument(
     const base::DictionaryValue& dictionary) {
   std::string id;
   if (!dictionary.GetString("legal_document_id", &id)) {
-    DLOG(ERROR) << "Response from Google Wallet missing legal document id";
+    DLOG(ERROR) << "Response from Google Payments missing legal document id";
     return scoped_ptr<LegalDocument>();
   }
 
   base::string16 display_name;
   if (!dictionary.GetString("display_name", &display_name)) {
-    DLOG(ERROR) << "Response from Google Wallet missing display name";
+    DLOG(ERROR) << "Response from Google Payments missing display name";
     return scoped_ptr<LegalDocument>();
   }
 
   std::string url;
   if (!dictionary.GetString("url", &url)) {
-    DLOG(ERROR) << "Response from Google Wallet missing URL";
+    DLOG(ERROR) << "Response from Google Payments missing URL";
     return scoped_ptr<LegalDocument>();
   }
 
   return scoped_ptr<LegalDocument>(
       new LegalDocument(id, GURL(url), display_name));
 }
 
 scoped_ptr<WalletItems::LegalDocument>
     WalletItems::LegalDocument::CreatePrivacyPolicyDocument() {
   return scoped_ptr<LegalDocument>(new LegalDocument(
@@ skipping 199 matching lines @@
                                          other.legal_documents()) &&
          allowed_shipping_countries() == other.allowed_shipping_countries();
 }
 
 bool WalletItems::operator!=(const WalletItems& other) const {
   return !(*this == other);
 }
 
 }  // namespace wallet
 }  // namespace autofill