Persist the choice of AutofillDataModel when using the requestAutocomplete dialog.

chrome/browser/ui/autofill/autofill_dialog_controller_impl.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 "chrome/browser/ui/autofill/autofill_dialog_controller_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autofill/personal_data_manager_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/shell_window_registry.h"
+#include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/autofill/autofill_dialog_view.h"
 #include "chrome/browser/ui/autofill/data_model_wrapper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/native_app_window.h"
 #include "chrome/browser/ui/extensions/shell_window.h"
 #include "chrome/common/chrome_version_info.h"
@@ skipping 52 matching lines @@
 // special value to the server to just ask for the maximum so we don't need to
 // hardcode it here (http://crbug.com/180731). TODO(dbeam): also maybe allow
 // users to give us this number via an <input> (http://crbug.com/180733).
 const int kCartMax = 1850;
 const char kCartCurrency[] = "USD";
 
 const char kAddNewItemKey[] = "add-new-item";
 const char kManageItemsKey[] = "manage-items";
 const char kSameAsBillingKey[] = "same-as-billing";
 
+// Keys for the kAutofillDialogAutofillDefault pref dictionary (do not change
+// these values).
+const char kGuidPrefKey[] = "guid";
+const char kVariantPrefKey[] = "variant";
+
 // This string is stored along with saved addresses and credit cards in the
 // WebDB, and hence should not be modified, so that it remains consistent over
 // time.
 const char kAutofillDialogOrigin[] = "Chrome Autofill dialog";
 
 // HSL shift to gray out an image.
 const color_utils::HSL kGrayImageShift = {-1, 0, 0.8};
 
 // Returns true if |input| should be shown when |field_type| has been requested.
 bool InputTypeMatchesFieldType(const DetailInput& input,
@@ skipping 129 matching lines @@
                          AutofillFieldType type) {
   for (DetailOutputMap::const_iterator it = output.begin();
        it != output.end(); ++it) {
     if (it->first->type == type)
       return it->second;
   }
   NOTREACHED();
   return string16();
 }
 
+// Returns a string descriptor for a DialogSection, for use with prefs (do not
+// change these values).
+std::string SectionToPrefString(DialogSection section) {
+  switch (section) {
+    case SECTION_CC:
+      return "cc";
+
+    case SECTION_BILLING:
+      return "billing";
+
+    case SECTION_CC_BILLING:
+      // The SECTION_CC_BILLING section isn't active when using Autofill.
+      NOTREACHED();
+      return std::string();
+
+    case SECTION_SHIPPING:
+      return "shipping";
+
+    case SECTION_EMAIL:
+      return "email";
+  }
+
+  NOTREACHED();
+  return std::string();
+}
+
 // Check if a given MaskedInstrument is allowed for the purchase.
 bool IsInstrumentAllowed(
     const wallet::WalletItems::MaskedInstrument& instrument) {
   return (instrument.status() == wallet::WalletItems::MaskedInstrument::VALID ||
       instrument.status() == wallet::WalletItems::MaskedInstrument::PENDING) &&
       instrument.type() != wallet::WalletItems::MaskedInstrument::AMEX &&
       instrument.type() != wallet::WalletItems::MaskedInstrument::UNKNOWN;
 }
 
 // Signals that the user has opted in to geolocation services.  Factored out
@@ skipping 56 matching lines @@
   return autofill_dialog_controller->weak_ptr_factory_.GetWeakPtr();
 }
 
 // static
 void AutofillDialogControllerImpl::RegisterUserPrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(
       ::prefs::kAutofillDialogPayWithoutWallet,
       kPayWithoutWalletDefault,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
+  registry->RegisterDictionaryPref(
+      ::prefs::kAutofillDialogAutofillDefault,
+      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 }
 
 void AutofillDialogControllerImpl::Show() {
   dialog_shown_timestamp_ = base::Time::Now();
 
   content::NavigationEntry* entry = contents_->GetController().GetActiveEntry();
   const GURL& active_url = entry ? entry->GetURL() : contents_->GetURL();
   invoked_from_same_origin_ = active_url.GetOrigin() == source_url_.GetOrigin();
 
   // Log any relevant UI metrics and security exceptions.
@@ skipping 650 matching lines @@
 
     return scoped_ptr<DataModelWrapper>();
   }
 
   if (section == SECTION_CC) {
     CreditCard* card = GetManager()->GetCreditCardByGUID(item_key);
     DCHECK(card);
     return scoped_ptr<DataModelWrapper>(new AutofillCreditCardWrapper(card));
   }
 
-  // Calculate the variant by looking at how many items come from the same
-  // data model.
-  size_t variant = 0;
-  for (int i = model->checked_item() - 1; i >= 0; --i) {
-    if (model->GetItemKeyAt(i) == item_key)
-      variant++;
-    else
-      break;
-  }
-
   AutofillProfile* profile = GetManager()->GetProfileByGUID(item_key);
   DCHECK(profile);
+  size_t variant = GetSelectedVariantForModel(*model);
   return scoped_ptr<DataModelWrapper>(
       new AutofillProfileWrapper(profile, variant));
 }
 
 gfx::Image AutofillDialogControllerImpl::SuggestionIconForSection(
     DialogSection section) {
   scoped_ptr<DataModelWrapper> model = CreateWrapper(section);
   if (!model.get())
     return gfx::Image();
 
@@ skipping 790 matching lines @@
       content::PAGE_TRANSITION_AUTO_BOOKMARK);
   params.disposition = NEW_FOREGROUND_TAB;
   chrome::Navigate(&params);
 #else
   // TODO(estade): use TabModelList?
 #endif
 }
 
 void AutofillDialogControllerImpl::DisableWallet() {
   signin_helper_.reset();
+  wallet_items_.reset();
+  GetWalletClient()->CancelRequests();
+  SetIsSubmitting(false);
   account_chooser_model_.SetHadWalletError();
-  GetWalletClient()->CancelRequests();
-  wallet_items_.reset();
-  full_wallet_.reset();
-  SetIsSubmitting(false);
 }
 
 void AutofillDialogControllerImpl::SuggestionsUpdated() {
   suggested_email_.Reset();
   suggested_cc_.Reset();
   suggested_billing_.Reset();
   suggested_cc_billing_.Reset();
   suggested_shipping_.Reset();
   HidePopup();
 
@@ skipping 134 matching lines @@
   }
 
   suggested_shipping_.AddKeyedItem(
       kAddNewItemKey,
       l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_ADD_SHIPPING_ADDRESS));
   suggested_shipping_.AddKeyedItem(
       kManageItemsKey,
       l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_MANAGE_SHIPPING_ADDRESS));
 
   if (!IsPayingWithWallet()) {
-    // When using Autofill, the default option is the first suggestion, if
-    // one exists. Otherwise it's the "Use shipping for billing" item.
-    const std::string& first_real_suggestion_item_key =
-        suggested_shipping_.GetItemKeyAt(1);
-    if (IsASuggestionItemKey(first_real_suggestion_item_key))
-      suggested_shipping_.SetCheckedItem(first_real_suggestion_item_key);
+    for (size_t i = SECTION_MIN; i <= SECTION_MAX; ++i) {
+      DialogSection section = static_cast<DialogSection>(i);
+      if (!SectionIsActive(section))
+        continue;
+
+      // Set the starting choice for the menu. First set to the default in case
+      // the GUID saved in prefs refers to a profile that no longer exists.
+      std::string guid;
+      int variant;
+      GetDefaultAutofillChoice(section, &guid, &variant);
+      SuggestionsMenuModel* model = SuggestionsMenuModelForSection(section);
+      model->SetCheckedItemNthWithKey(guid, variant + 1);
+      if (GetAutofillChoice(section, &guid, &variant))
+        model->SetCheckedItemNthWithKey(guid, variant + 1);
+    }
   }
 
   if (view_)
     view_->ModelChanged();
 
   for (size_t section = SECTION_MIN; section <= SECTION_MAX; ++section) {
     PrepareDetailInputsForSection(static_cast<DialogSection>(section));
   }
 }
 
@@ skipping 287 matching lines @@
   // switching payment methods, so only ask the view whether to save details
   // locally if that checkbox is showing (currently if not paying with wallet).
   // Also, if the user isn't editing any sections, there's no data to save
   // locally.
   return ShouldOfferToSaveInChrome() && view_->SaveDetailsLocally();
 }
 
 void AutofillDialogControllerImpl::SetIsSubmitting(bool submitting) {
   is_submitting_ = submitting;
 
+  if (!submitting)
+    full_wallet_.reset();
+
   if (view_) {
     view_->UpdateButtonStrip();
     view_->UpdateNotificationArea();
   }
 }
 
 void AutofillDialogControllerImpl::SubmitWithWallet() {
   // TODO(dbeam): disallow interacting with the dialog while submitting.
   // http://crbug.com/230932
 
@@ skipping 192 matching lines @@
     FillOutputForSectionWithComparator(
         SECTION_CC,
         base::Bind(DetailInputMatchesShippingField));
     FillOutputForSectionWithComparator(
         SECTION_CC_BILLING,
         base::Bind(DetailInputMatchesShippingField));
   } else {
     FillOutputForSection(SECTION_SHIPPING);
   }
 
+  if (!IsPayingWithWallet()) {
+    for (size_t i = SECTION_MIN; i <= SECTION_MAX; ++i) {
+      DialogSection section = static_cast<DialogSection>(i);
+      if (!SectionIsActive(section))
+        continue;
+
+      SuggestionsMenuModel* model = SuggestionsMenuModelForSection(section);
+      std::string item_key = model->GetItemKeyForCheckedItem();
+      if (IsASuggestionItemKey(item_key) || item_key == kSameAsBillingKey) {
+        int variant = GetSelectedVariantForModel(*model);
+        PersistAutofillChoice(section, item_key, variant);
+      }
+    }
+  }
+
   callback_.Run(&form_structure_, !wallet_items_ ? std::string() :
       wallet_items_->google_transaction_id());
   callback_ = base::Callback<void(const FormStructure*, const std::string&)>();
 
   LogOnFinishSubmitMetrics();
 
   // On a successful submit, if the user manually selected "pay without wallet",
   // stop trying to pay with Wallet on future runs of the dialog.
   bool manually_selected_pay_without_wallet =
       !account_chooser_model_.WalletIsSelected() &&
@@ skipping 14 matching lines @@
       view_->UpdateNotificationArea();
       break;
 
     case DIALOG_TYPE_REQUEST_AUTOCOMPLETE:
       // This may delete us.
       Hide();
       break;
   }
 }
 
+void AutofillDialogControllerImpl::PersistAutofillChoice(
+    DialogSection section,
+    const std::string& guid,
+    int variant) {
+  DCHECK(!IsPayingWithWallet());
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  value->SetString(kGuidPrefKey, guid);
+  value->SetInteger(kVariantPrefKey, variant);
+
+  DictionaryPrefUpdate updater(profile()->GetPrefs(),
+                               ::prefs::kAutofillDialogAutofillDefault);
+  base::DictionaryValue* autofill_choice = updater.Get();
+  autofill_choice->Set(SectionToPrefString(section), value.release());
+}
+
+void AutofillDialogControllerImpl::GetDefaultAutofillChoice(
+    DialogSection section,
+    std::string* guid,
+    int* variant) {
+  DCHECK(!IsPayingWithWallet());
+  // The default choice is the first thing in the menu that is a suggestion
+  // item.
+  *variant = 0;
+  SuggestionsMenuModel* model = SuggestionsMenuModelForSection(section);
+  for (int i = 0; i < model->GetItemCount(); ++i) {
+    if (IsASuggestionItemKey(model->GetItemKeyAt(i))) {
+      *guid = model->GetItemKeyAt(i);
+      break;
+    }
+  }
+}
+
+bool AutofillDialogControllerImpl::GetAutofillChoice(DialogSection section,
+                                                     std::string* guid,
+                                                     int* variant) {
+  DCHECK(!IsPayingWithWallet());
+  const base::DictionaryValue* choices = profile()->GetPrefs()->GetDictionary(
+      ::prefs::kAutofillDialogAutofillDefault);
+  if (!choices)
+    return false;
+
+  const base::DictionaryValue* choice = NULL;
+  if (!choices->GetDictionary(SectionToPrefString(section), &choice))
+    return false;
+
+  choice->GetString(kGuidPrefKey, guid);
+  choice->GetInteger(kVariantPrefKey, variant);
+  return true;
+}
+
+size_t AutofillDialogControllerImpl::GetSelectedVariantForModel(
+    const SuggestionsMenuModel& model) {
+  size_t variant = 0;
+  // Calculate the variant by looking at how many items come from the same
+  // data model.
+  for (int i = model.checked_item() - 1; i >= 0; --i) {
+    if (model.GetItemKeyAt(i) == model.GetItemKeyForCheckedItem())
+      variant++;
+    else
+      break;
+  }
+  return variant;
+}
+
 void AutofillDialogControllerImpl::LogOnFinishSubmitMetrics() {
   GetMetricLogger().LogDialogUiDuration(
       base::Time::Now() - dialog_shown_timestamp_,
       GetDialogType(),
       AutofillMetrics::DIALOG_ACCEPTED);
 
   GetMetricLogger().LogDialogUiEvent(
       GetDialogType(), AutofillMetrics::DIALOG_UI_ACCEPTED);
 
   AutofillMetrics::DialogDismissalState dismissal_state;
@@ skipping 83 matching lines @@
         AutofillMetrics::DIALOG_USER_SIGNED_IN_NO_WALLET_NO_AUTOFILL;
   }
 
   // Has Wallet items.
   return has_autofill_profiles ?
       AutofillMetrics::DIALOG_USER_SIGNED_IN_HAS_WALLET_HAS_AUTOFILL :
       AutofillMetrics::DIALOG_USER_SIGNED_IN_HAS_WALLET_NO_AUTOFILL;
 }
 
 }  // namespace autofill