Autofill:requestAutocomplete: Enable prompting for complete address when instrument being used does…

components/autofill/browser/wallet/wallet_address.cc

 // Copyright (c) 2012 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/browser/wallet/wallet_address.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/autofill/browser/autofill_country.h"
 #include "components/autofill/browser/autofill_profile.h"
 
 namespace autofill {
 namespace wallet {
 
+// Server specified type for address with complete details.
+const char kFullAddress[] = "FULL";
+const char kTrue[] = "true";
+
 namespace {
 
 Address* CreateAddressInternal(const base::DictionaryValue& dictionary,
                                const std::string& object_id) {
   std::string country_name_code;
   if (!dictionary.GetString("postal_address.country_name_code",
                             &country_name_code)) {
     DLOG(ERROR) << "Response from Google Wallet missing country name";
     return NULL;
   }
 
   string16 recipient_name;
   if (!dictionary.GetString("postal_address.recipient_name",
                             &recipient_name)) {
-    DLOG(ERROR) << "Response from Google Wallet recipient name";
+    DLOG(ERROR) << "Response from Google Wallet missing recipient name";
     return NULL;
   }
 
   string16 postal_code_number;
   if (!dictionary.GetString("postal_address.postal_code_number",
                             &postal_code_number)) {
     DLOG(ERROR) << "Response from Google Wallet missing postal code number";
     return NULL;
   }
 
@@ skipping 18 matching lines @@
                             &locality_name)) {
     DVLOG(1) << "Response from Google Wallet missing locality name";
   }
 
   string16 administrative_area_name;
   if (!dictionary.GetString("postal_address.administrative_area_name",
                             &administrative_area_name)) {
     DVLOG(1) << "Response from Google Wallet missing administrative area name";
   }
 
-  return new Address(country_name_code,
-                     recipient_name ,
-                     address_line_1,
-                     address_line_2,
-                     locality_name,
-                     administrative_area_name,
-                     postal_code_number,
-                     phone_number,
-                     object_id);
+  std::string is_minimal_address;
+  if (!dictionary.GetString("is_minimal_address", &is_minimal_address))
+    DVLOG(1) << "Response from Google Wallet missing is_minimal_address bit";
+
+  Address* address = new Address(country_name_code,
+                                 recipient_name,
+                                 address_line_1,
+                                 address_line_2,
+                                 locality_name,
+                                 administrative_area_name,
+                                 postal_code_number,
+                                 phone_number,
+                                 object_id);
+  address->set_is_complete_address(is_minimal_address != kTrue);
+
+  return address;
 }
 
 }  // namespace
 
 Address::Address() {}
 
 Address::Address(const AutofillProfile& profile)
     : country_name_code_(
           UTF16ToASCII(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))),
       recipient_name_(profile.GetRawInfo(NAME_FULL)),
       address_line_1_(profile.GetRawInfo(ADDRESS_HOME_LINE1)),
       address_line_2_(profile.GetRawInfo(ADDRESS_HOME_LINE2)),
       locality_name_(profile.GetRawInfo(ADDRESS_HOME_CITY)),
       administrative_area_name_(profile.GetRawInfo(ADDRESS_HOME_STATE)),
       postal_code_number_(profile.GetRawInfo(ADDRESS_HOME_ZIP)),
-      phone_number_(profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER)) {}
+      phone_number_(profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER)),
+      is_complete_address_(true) {}
 
 Address::Address(const std::string& country_name_code,
                  const string16& recipient_name,
                  const string16& address_line_1,
                  const string16& address_line_2,
                  const string16& locality_name,
                  const string16& administrative_area_name,
                  const string16& postal_code_number,
                  const string16& phone_number,
                  const std::string& object_id)
     : country_name_code_(country_name_code),
       recipient_name_(recipient_name),
       address_line_1_(address_line_1),
       address_line_2_(address_line_2),
       locality_name_(locality_name),
       administrative_area_name_(administrative_area_name),
       postal_code_number_(postal_code_number),
       phone_number_(phone_number),
-      object_id_(object_id) {}
+      object_id_(object_id),
+      is_complete_address_(true) {}
 
 Address::~Address() {}
 
 // static
 scoped_ptr<Address> Address::CreateAddressWithID(
     const base::DictionaryValue& dictionary) {
   std::string object_id;
   if (!dictionary.GetString("id", &object_id)) {
     DLOG(ERROR) << "Response from Google Wallet missing object id";
     return scoped_ptr<Address>();
@@ skipping 43 matching lines @@
     DVLOG(1) << "Reponse from Google Wallet missing city";
 
   string16 state;
   if (!dictionary.GetString("state", &state))
     DVLOG(1) << "Reponse from Google Wallet missing state";
 
   string16 phone_number;
   if (!dictionary.GetString("phone_number", &phone_number))
     DVLOG(1) << "Reponse from Google Wallet missing phone number";
 
-  return scoped_ptr<Address>(new Address(country_code,
-                                         name,
-                                         address1,
-                                         address2,
-                                         city,
-                                         state,
-                                         postal_code,
-                                         phone_number,
-                                         std::string()));
+  std::string address_state;
+  if (!dictionary.GetString("type", &address_state))
+    DVLOG(1) << "Response from Google Wallet missing type/state of address";
+
+  scoped_ptr<Address> address(
+      new Address(country_code,
+                  name,
+                  address1,
+                  address2,
+                  city,
+                  state,
+                  postal_code,
+                  phone_number,
+                  std::string()));
+  address->set_is_complete_address(address_state == kFullAddress);
+
+  return address.Pass();
 }
 
 scoped_ptr<base::DictionaryValue> Address::ToDictionaryWithID() const {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
   if (!object_id_.empty())
     dict->SetString("id", object_id_);
   dict->SetString("phone_number", phone_number_);
   dict->Set("postal_address", ToDictionaryWithoutID().release());
 
@@ skipping 76 matching lines @@
 
 bool Address::operator==(const Address& other) const {
   return country_name_code_ == other.country_name_code_ &&
          recipient_name_ == other.recipient_name_ &&
          address_line_1_ == other.address_line_1_ &&
          address_line_2_ == other.address_line_2_ &&
          locality_name_ == other.locality_name_ &&
          administrative_area_name_ == other.administrative_area_name_ &&
          postal_code_number_ == other.postal_code_number_ &&
          phone_number_ == other.phone_number_ &&
-         object_id_ == other.object_id_;
+         object_id_ == other.object_id_ &&
+         is_complete_address_ == other.is_complete_address_;
 }
 
 bool Address::operator!=(const Address& other) const {
   return !(*this == other);
 }
 
 }  // namespace wallet
 }  // namespace autofill