Change the behavior of the [X] Save details to Wallet checkbox notification to:

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"
@@ skipping 361 matching lines @@
   // fields. First we must figure out what the "right" fields are.
   view_.reset(CreateView());
   view_->Show();
   GetManager()->AddObserver(this);
 
   // Try to see if the user is already signed-in.
   // If signed-in, fetch the user's Wallet data.
   // Otherwise, see if the user could be signed in passively.
   // TODO(aruslan): UMA metrics for sign-in.
   if (account_chooser_model_.WalletIsSelected())
-    StartFetchingWalletItems();
+    GetWalletItems();
 }
 
 void AutofillDialogControllerImpl::Hide() {
   if (view_)
     view_->Hide();
 }
 
 void AutofillDialogControllerImpl::UpdateProgressBar(double value) {
   view_->UpdateProgressBar(value);
 }
@@ skipping 129 matching lines @@
   return wallet_items_.get() != NULL &&
          !wallet_items_->instruments().empty() &&
          !wallet_items_->addresses().empty();
 }
 
 bool AutofillDialogControllerImpl::IsSubmitPausedOn(
     wallet::RequiredAction required_action) const {
   return full_wallet_ && full_wallet_->HasRequiredAction(required_action);
 }
 
-void AutofillDialogControllerImpl::StartFetchingWalletItems() {
+void AutofillDialogControllerImpl::GetWalletItems() {
   // TODO(dbeam): Add Risk capabilites once the UI supports risk challenges.
   GetWalletClient()->GetWalletItems(
-      source_url_,
-      std::vector<wallet::WalletClient::RiskCapability>());
+      source_url_, std::vector<wallet::WalletClient::RiskCapability>());
 }
 
 void AutofillDialogControllerImpl::OnWalletOrSigninUpdate() {
-  if (wallet_items_.get()) {
-    DCHECK(!signin_helper_.get());
-    switch (SignedInState()) {
-      case SIGNED_IN:
-        // Start fetching the user name if we don't know it yet.
-        if (current_username_.empty()) {
-          signin_helper_.reset(new wallet::WalletSigninHelper(
-              this,
-              profile_->GetRequestContext()));
-          signin_helper_->StartUserNameFetch();
-        }
-        break;
+  switch (SignedInState()) {
+    case SIGNED_IN:
+      // Start fetching the user name if we don't know it yet.
+      if (current_username_.empty()) {
+        signin_helper_.reset(new wallet::WalletSigninHelper(
+            this, profile_->GetRequestContext()));
+        signin_helper_->StartUserNameFetch();
+      }
+      break;
 
-      case REQUIRES_SIGN_IN:
-        // TODO(aruslan): automatic sign-in?
-        break;
+    case REQUIRES_SIGN_IN:
+      // TODO(aruslan): automatic sign-in?
+      break;
 
-      case REQUIRES_PASSIVE_SIGN_IN:
-        // Attempt to passively sign in the user.
-        current_username_.clear();
-        signin_helper_.reset(new wallet::WalletSigninHelper(
-            this,
-            profile_->GetRequestContext()));
-        signin_helper_->StartPassiveSignin();
-        break;
+    case REQUIRES_PASSIVE_SIGN_IN:
+      // Attempt to passively sign in the user.
+      current_username_.clear();
+      signin_helper_.reset(new wallet::WalletSigninHelper(
+          this, profile_->GetRequestContext()));
+      signin_helper_->StartPassiveSignin();
+      break;
 
-      case REQUIRES_RESPONSE:
-        NOTREACHED();
-    }
+    case REQUIRES_RESPONSE:
+      break;
   }
 
   SuggestionsUpdated();
   view_->UpdateAccountChooser();
   view_->UpdateNotificationArea();
 
   // On the first successful response, compute the initial user state metric.
   if (initial_user_state_ == AutofillMetrics::DIALOG_USER_STATE_UNKNOWN)
     initial_user_state_ = GetInitialUserState();
 }
@@ skipping 500 matching lines @@
   if (autocheckout_is_running_ || had_autocheckout_error_) {
     AutofillMetrics::AutocheckoutCompletionStatus metric =
         autocheckout_is_running_ ?
             AutofillMetrics::AUTOCHECKOUT_SUCCEEDED :
             AutofillMetrics::AUTOCHECKOUT_FAILED;
     GetMetricLogger().LogAutocheckoutDuration(
         base::Time::Now() - autocheckout_started_timestamp_,
         metric);
   }
 
-  // Reset the view so that updates to the pref aren't processed.
-  view_.reset();
-  // 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() &&
-      !account_chooser_model_.had_wallet_error();
-  profile_->GetPrefs()->SetBoolean(prefs::kAutofillDialogPayWithoutWallet,
-                                   manually_selected_pay_without_wallet);
-
   delete this;
 }
 
 std::vector<DialogNotification>
     AutofillDialogControllerImpl::CurrentNotifications() const {
   std::vector<DialogNotification> notifications;
 
-  if (account_chooser_model_.WalletIsSelected()) {
-    if (SignedInState() == SIGNED_IN) {
-      // On first run with a complete wallet profile, show a notification
-      // explaining where this data came from.
-      if (IsFirstRun() && HasCompleteWallet()) {
+  if (account_chooser_model_.had_wallet_error()) {
+    // TODO(dbeam): pass along the Wallet error or remove from the translation.
+    // TODO(dbeam): figure out a way to dismiss this error after a while.
+    notifications.push_back(DialogNotification(
+        DialogNotification::WALLET_ERROR,
+        l10n_util::GetStringFUTF16(IDS_AUTOFILL_DIALOG_COMPLETE_WITHOUT_WALLET,
+                                   ASCIIToUTF16("[Wallet-Error]."))));
+  } else {
+    if (IsFirstRun()) {
+      if (SignedInState() == SIGNED_IN) {
+        if (account_chooser_model_.WalletIsSelected() && HasCompleteWallet()) {
+          // First run, signed in, has a complete Google Wallet.
+          notifications.push_back(DialogNotification(
+              DialogNotification::EXPLANATORY_MESSAGE,
+              l10n_util::GetStringUTF16(
+                  IDS_AUTOFILL_DIALOG_DETAILS_FROM_WALLET)));
+        } else {
+          // First run, signed in, has an incomplete (or no) Google Wallet.
+          DialogNotification notification(
+              DialogNotification::WALLET_USAGE_CONFIRMATION,
+              l10n_util::GetStringUTF16(
+                  IDS_AUTOFILL_DIALOG_SAVE_DETAILS_IN_WALLET));
+          notification.set_checked(account_chooser_model_.WalletIsSelected());
+          notification.set_interactive(!is_submitting_);
+          notifications.push_back(notification);
+        }
+      } else if (account_chooser_model_.WalletIsSelected()) {
+        // First run, not signed in, wallet promo.
         notifications.push_back(DialogNotification(
-            DialogNotification::EXPLANATORY_MESSAGE,
+            DialogNotification::WALLET_SIGNIN_PROMO,
             l10n_util::GetStringUTF16(
-                IDS_AUTOFILL_DIALOG_DETAILS_FROM_WALLET)));
-      } else {
-        notifications.push_back(DialogNotification(
-            DialogNotification::WALLET_USAGE_CONFIRMATION,
-            l10n_util::GetStringUTF16(
-                IDS_AUTOFILL_DIALOG_SAVE_DETAILS_IN_WALLET)));
-        notifications.back().set_interactive(!is_submitting_);
+                IDS_AUTOFILL_DIALOG_SIGN_IN_AND_SAVE_DETAILS)));
       }
-    } else if (IsFirstRun()) {
-      // If the user is not signed in, show an upsell notification on first run.
-      notifications.push_back(DialogNotification(
-          DialogNotification::WALLET_SIGNIN_PROMO,
+    } else if (SignedInState() == SIGNED_IN && !HasCompleteWallet()) {
+      // After first run, signed in.
+      DialogNotification notification(
+          DialogNotification::WALLET_USAGE_CONFIRMATION,
           l10n_util::GetStringUTF16(
-              IDS_AUTOFILL_DIALOG_SIGN_IN_AND_SAVE_DETAILS)));
+              IDS_AUTOFILL_DIALOG_SAVE_DETAILS_IN_WALLET));
+      notification.set_checked(account_chooser_model_.WalletIsSelected());
+      notification.set_interactive(!is_submitting_);
+      notifications.push_back(notification);
+    } else {
+      // If the user isn't signed in and it's after the first run, no promo.
     }
   }
 
   if (RequestingCreditCardInfo() && !TransmissionWillBeSecure()) {
     notifications.push_back(DialogNotification(
         DialogNotification::SECURITY_WARNING,
         l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_SECURITY_WARNING)));
   }
 
   if (!invoked_from_same_origin_) {
     notifications.push_back(DialogNotification(
         DialogNotification::SECURITY_WARNING,
         l10n_util::GetStringFUTF16(IDS_AUTOFILL_DIALOG_SITE_WARNING,
                                    UTF8ToUTF16(source_url_.host()))));
   }
 
   if (IsSubmitPausedOn(wallet::VERIFY_CVV)) {
     notifications.push_back(DialogNotification(
             DialogNotification::REQUIRED_ACTION,
             l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_VERIFY_CVV)));
   }
 
   if (had_autocheckout_error_) {
     notifications.push_back(DialogNotification(
         DialogNotification::AUTOCHECKOUT_ERROR,
         l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_AUTOCHECKOUT_ERROR)));
   }
 
-  if (account_chooser_model_.had_wallet_error()) {
-    // TODO(dbeam): pass along the Wallet error or remove from the translation.
-    // TODO(dbeam): figure out a way to dismiss this error after a while.
-    notifications.push_back(DialogNotification(
-        DialogNotification::WALLET_ERROR,
-        l10n_util::GetStringFUTF16(
-            IDS_AUTOFILL_DIALOG_COMPLETE_WITHOUT_WALLET,
-            ASCIIToUTF16("[Wallet-Error]."))));
-  }
-
   return notifications;
 }
 
 void AutofillDialogControllerImpl::StartSignInFlow() {
   DCHECK(registrar_.IsEmpty());
 
   content::Source<content::NavigationController> source(view_->ShowSignIn());
   registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED, source);
 }
 
 void AutofillDialogControllerImpl::EndSignInFlow() {
   DCHECK(!registrar_.IsEmpty());
   registrar_.RemoveAll();
   view_->HideSignIn();
 }
 
+void AutofillDialogControllerImpl::NotificationCheckboxStateChanged(
+    DialogNotification::Type type, bool checked) {
+  if (type == DialogNotification::WALLET_USAGE_CONFIRMATION) {
+    int command = checked ? AccountChooserModel::kWalletItemId :
+                            AccountChooserModel::kAutofillItemId;
+    account_chooser_model_.ExecuteCommand(command, 0);
+  }
+}
+
 void AutofillDialogControllerImpl::LegalDocumentLinkClicked(
     const ui::Range& range) {
 #if !defined(OS_ANDROID)
   for (size_t i = 0; i < legal_document_link_ranges_.size(); ++i) {
     if (legal_document_link_ranges_[i] == range) {
       chrome::NavigateParams params(
           chrome::FindBrowserWithWebContents(web_contents()),
           wallet_items_->legal_documents()[i]->url(),
           content::PAGE_TRANSITION_AUTO_BOOKMARK);
       params.disposition = NEW_BACKGROUND_TAB;
@@ skipping 115 matching lines @@
 void AutofillDialogControllerImpl::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(type, content::NOTIFICATION_NAV_ENTRY_COMMITTED);
   content::LoadCommittedDetails* load_details =
       content::Details<content::LoadCommittedDetails>(details).ptr();
   if (wallet::IsSignInContinueUrl(load_details->entry->GetVirtualURL())) {
     EndSignInFlow();
     if (account_chooser_model_.WalletIsSelected())
-      StartFetchingWalletItems();
+      GetWalletItems();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SuggestionsMenuModelDelegate implementation.
 
 void AutofillDialogControllerImpl::SuggestionItemSelected(
     const SuggestionsMenuModel& model) {
   const DialogSection section = SectionForSuggestionsMenuModel(model);
   EditCancelledForSection(section);
@@ skipping 43 matching lines @@
 
   SuggestionsUpdated();
   view_->UpdateNotificationArea();
   view_->UpdateButtonStrip();
 }
 
 void AutofillDialogControllerImpl::OnPassiveSigninSuccess(
     const std::string& username) {
   current_username_ = username;
   signin_helper_.reset();
-  wallet_items_.reset();
-  StartFetchingWalletItems();
+  GetWalletItems();
 }
 
 void AutofillDialogControllerImpl::OnUserNameFetchSuccess(
     const std::string& username) {
   current_username_ = username;
   signin_helper_.reset();
   OnWalletOrSigninUpdate();
 }
 
 void AutofillDialogControllerImpl::OnAutomaticSigninSuccess(
@@ skipping 96 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PersonalDataManagerObserver implementation.
 
 void AutofillDialogControllerImpl::OnPersonalDataChanged() {
   SuggestionsUpdated();
 }
 
 void AutofillDialogControllerImpl::AccountChoiceChanged() {
-  if (!view_)
-    return;
-
   // Whenever the user changes the account, all manual inputs should be reset.
   ResetManualInputForSection(SECTION_EMAIL);
   ResetManualInputForSection(SECTION_CC);
   ResetManualInputForSection(SECTION_BILLING);
   ResetManualInputForSection(SECTION_CC_BILLING);
   ResetManualInputForSection(SECTION_SHIPPING);
 
-  // Whenever the user changes the current account, the Wallet data should be
-  // cleared. If the user has chosen a Wallet account, an attempt to fetch
-  // the Wallet data is made to see if the user is still signed in.
-  // This will trigger a passive sign-in if required.
-  wallet_items_.reset();
-  full_wallet_.reset();
-  GetWalletClient()->CancelRequests();
+  if (is_submitting_)
+    GetWalletClient()->CancelRequests();
 
   SetIsSubmitting(false);
 
-  // TODO(aruslan): integrate an automatic sign-in.
-  if (account_chooser_model_.WalletIsSelected())
-    StartFetchingWalletItems();
+  if (account_chooser_model_.WalletIsSelected() && !wallet_items_)
+    GetWalletItems();
 
   SuggestionsUpdated();
-  view_->UpdateAccountChooser();
-  view_->UpdateNotificationArea();
+
+  if (view_) {
+    view_->UpdateAccountChooser();
+    view_->UpdateNotificationArea();
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool AutofillDialogControllerImpl::HandleKeyPressEventInInput(
     const content::NativeWebKeyboardEvent& event) {
   if (popup_controller_)
     return popup_controller_->HandleKeyPressEvent(event);
 
   return false;
@@ skipping 36 matching lines @@
           wallet_client_(profile_->GetRequestContext(), this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(suggested_email_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(suggested_cc_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(suggested_billing_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(suggested_cc_billing_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(suggested_shipping_(this)),
       input_showing_popup_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       initial_user_state_(AutofillMetrics::DIALOG_USER_STATE_UNKNOWN),
       dialog_type_(dialog_type),
+      is_first_run_(!profile_->GetPrefs()->HasPrefPath(
+          prefs::kAutofillDialogPayWithoutWallet)),
       is_submitting_(false),
       autocheckout_is_running_(false),
       had_autocheckout_error_(false) {
   // TODO(estade): remove duplicates from |form_structure|?
   DCHECK(!callback_.is_null());
 }
 
 AutofillDialogView* AutofillDialogControllerImpl::CreateView() {
   return AutofillDialogView::Create(this);
 }
 
 PersonalDataManager* AutofillDialogControllerImpl::GetManager() {
   return PersonalDataManagerFactory::GetForProfile(profile_);
 }
 
 wallet::WalletClient* AutofillDialogControllerImpl::GetWalletClient() {
   return &wallet_client_;
 }
 
 bool AutofillDialogControllerImpl::IsPayingWithWallet() const {
   return account_chooser_model_.WalletIsSelected() &&
          SignedInState() == SIGNED_IN;
 }
 
+bool AutofillDialogControllerImpl::IsFirstRun() const {
+  return is_first_run_;
+}
+
 void AutofillDialogControllerImpl::DisableWallet() {
   signin_helper_.reset();
   current_username_.clear();
   account_chooser_model_.SetHadWalletError();
   GetWalletClient()->CancelRequests();
   wallet_items_.reset();
   full_wallet_.reset();
   SetIsSubmitting(false);
 }
 
-bool AutofillDialogControllerImpl::IsFirstRun() const {
-  PrefService* prefs = profile_->GetPrefs();
-  return !prefs->HasPrefPath(prefs::kAutofillDialogPayWithoutWallet);
-}
-
 void AutofillDialogControllerImpl::SuggestionsUpdated() {
   suggested_email_.Reset();
   suggested_cc_.Reset();
   suggested_billing_.Reset();
   suggested_cc_billing_.Reset();
   suggested_shipping_.Reset();
   HidePopup();
 
   if (IsPayingWithWallet()) {
     // TODO(estade): fill in the email address.
@@ skipping 455 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