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/base_window.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"
@@ skipping 48 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";
+
 // Returns true if |input| should be shown when |field_type| has been requested.
 bool InputTypeMatchesFieldType(const DetailInput& input,
                                AutofillFieldType field_type) {
   // If any credit card expiration info is asked for, show both month and year
   // inputs.
   if (field_type == CREDIT_CARD_EXP_4_DIGIT_YEAR ||
       field_type == CREDIT_CARD_EXP_2_DIGIT_YEAR ||
       field_type == CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR ||
       field_type == CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR ||
       field_type == CREDIT_CARD_EXP_MONTH) {
@@ skipping 121 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();
+}
+
 }  // namespace
 
 AutofillDialogController::~AutofillDialogController() {}
 
 AutofillDialogControllerImpl::~AutofillDialogControllerImpl() {
   if (popup_controller_)
     popup_controller_->Hide();
 
   GetMetricLogger().LogDialogInitialUserState(
       GetDialogType(), initial_user_state_);
@@ skipping 18 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 653 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 904 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 508 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