Remove autocheckout code.

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 <map>
 #include <string>
 
@@ skipping 424 matching lines @@
 }  // namespace
 
 AutofillDialogViewDelegate::~AutofillDialogViewDelegate() {}
 
 AutofillDialogControllerImpl::~AutofillDialogControllerImpl() {
   if (popup_controller_)
     popup_controller_->Hide();
 
   GetMetricLogger().LogDialogInitialUserState(
       GetDialogType(), initial_user_state_);
-
-  if (deemphasized_render_view_ && web_contents()) {
-    web_contents()->GetRenderViewHost()->Send(
-        new ChromeViewMsg_SetVisuallyDeemphasized(
-            web_contents()->GetRenderViewHost()->GetRoutingID(), false));
-  }
 }
 
 // static
 base::WeakPtr<AutofillDialogControllerImpl>
     AutofillDialogControllerImpl::Create(
     content::WebContents* contents,
     const FormData& form_structure,
     const GURL& source_url,
     const DialogType dialog_type,
     const base::Callback<void(const FormStructure*,
@@ skipping 142 matching lines @@
   // If the user switched away from this tab and then switched back, reload the
   // Wallet items, in case they've changed.
   int seconds_elapsed_since_last_refresh =
       (base::TimeTicks::Now() - last_wallet_items_fetch_timestamp_).InSeconds();
   if (IsPayingWithWallet() && wallet_items_ &&
       seconds_elapsed_since_last_refresh >= kWalletItemsRefreshRateSeconds) {
     GetWalletItems();
   }
 }
 
-void AutofillDialogControllerImpl::OnAutocheckoutError() {
-  DCHECK_EQ(AUTOCHECKOUT_IN_PROGRESS, autocheckout_state_);
-  GetMetricLogger().LogAutocheckoutDuration(
-      base::Time::Now() - autocheckout_started_timestamp_,
-      AutofillMetrics::AUTOCHECKOUT_FAILED);
-  SetAutocheckoutState(AUTOCHECKOUT_ERROR);
-  autocheckout_started_timestamp_ = base::Time();
-}
-
-void AutofillDialogControllerImpl::OnAutocheckoutSuccess() {
-  DCHECK_EQ(AUTOCHECKOUT_IN_PROGRESS, autocheckout_state_);
-  GetMetricLogger().LogAutocheckoutDuration(
-      base::Time::Now() - autocheckout_started_timestamp_,
-      AutofillMetrics::AUTOCHECKOUT_SUCCEEDED);
-  SetAutocheckoutState(AUTOCHECKOUT_SUCCESS);
-  autocheckout_started_timestamp_ = base::Time();
-}
-
-
 TestableAutofillDialogView* AutofillDialogControllerImpl::GetTestableView() {
   return view_ ? view_->GetTestableView() : NULL;
 }
 
-void AutofillDialogControllerImpl::AddAutocheckoutStep(
-    AutocheckoutStepType step_type) {
-  for (size_t i = 0; i < steps_.size(); ++i) {
-    if (steps_[i].type() == step_type)
-      return;
-  }
-  steps_.push_back(
-      DialogAutocheckoutStep(step_type, AUTOCHECKOUT_STEP_UNSTARTED));
-}
-
-void AutofillDialogControllerImpl::UpdateAutocheckoutStep(
-    AutocheckoutStepType step_type,
-    AutocheckoutStepStatus step_status) {
-  ScopedViewUpdates updates(view_.get());
-
-  int total_steps = 0;
-  int completed_steps = 0;
-  for (size_t i = 0; i < steps_.size(); ++i) {
-    ++total_steps;
-    if (steps_[i].status() == AUTOCHECKOUT_STEP_COMPLETED)
-      ++completed_steps;
-    if (steps_[i].type() == step_type && steps_[i].status() != step_status)
-      steps_[i] = DialogAutocheckoutStep(step_type, step_status);
-  }
-  if (view_) {
-    view_->UpdateAutocheckoutStepsArea();
-    view_->UpdateProgressBar(1.0 * completed_steps / total_steps);
-  }
-}
-
-std::vector<DialogAutocheckoutStep>
-    AutofillDialogControllerImpl::CurrentAutocheckoutSteps() const {
-  if (autocheckout_state_ != AUTOCHECKOUT_NOT_STARTED)
-    return steps_;
-
-  std::vector<DialogAutocheckoutStep> empty_steps;
-  return empty_steps;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // AutofillDialogViewDelegate implementation.
 
 string16 AutofillDialogControllerImpl::DialogTitle() const {
   return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_TITLE);
 }
 
 string16 AutofillDialogControllerImpl::EditSuggestionText() const {
   return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_EDIT);
 }
 
 string16 AutofillDialogControllerImpl::CancelButtonText() const {
   return l10n_util::GetStringUTF16(IDS_CANCEL);
 }
 
 string16 AutofillDialogControllerImpl::ConfirmButtonText() const {
-  if (autocheckout_state_ == AUTOCHECKOUT_ERROR)
-    return l10n_util::GetStringUTF16(IDS_OK);
-  if (autocheckout_state_ == AUTOCHECKOUT_SUCCESS)
-    return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_CONTINUE_BUTTON);
-
   return l10n_util::GetStringUTF16(IsSubmitPausedOn(wallet::VERIFY_CVV) ?
       IDS_AUTOFILL_DIALOG_VERIFY_BUTTON : IDS_AUTOFILL_DIALOG_SUBMIT_BUTTON);
 }
 
 string16 AutofillDialogControllerImpl::SaveLocallyText() const {
   return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_SAVE_LOCALLY_CHECKBOX);
 }
 
 string16 AutofillDialogControllerImpl::SaveLocallyTooltip() const {
   return l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_SAVE_LOCALLY_TOOLTIP);
 }
 
 string16 AutofillDialogControllerImpl::LegalDocumentsText() {
-  if (!IsPayingWithWallet() || autocheckout_state_ != AUTOCHECKOUT_NOT_STARTED)
+  if (!IsPayingWithWallet())
     return string16();
 
   EnsureLegalDocumentsText();
   return legal_documents_text_;
 }
 
 DialogSignedInState AutofillDialogControllerImpl::SignedInState() const {
   if (account_chooser_model_.HadWalletError())
     return SIGN_IN_DISABLED;
 
@@ skipping 28 matching lines @@
 string16 AutofillDialogControllerImpl::SignInLinkText() const {
   return l10n_util::GetStringUTF16(
       signin_registrar_.IsEmpty() ? IDS_AUTOFILL_DIALOG_SIGN_IN :
                                     IDS_AUTOFILL_DIALOG_CANCEL_SIGN_IN);
 }
 
 bool AutofillDialogControllerImpl::ShouldOfferToSaveInChrome() const {
   return !IsPayingWithWallet() &&
       !profile_->IsOffTheRecord() &&
       IsManuallyEditingAnySection() &&
-      ShouldShowDetailArea() &&
       !ShouldShowSpinner();
 }
 
 int AutofillDialogControllerImpl::GetDialogButtons() const {
-  if (autocheckout_state_ == AUTOCHECKOUT_IN_PROGRESS)
-    return ui::DIALOG_BUTTON_CANCEL;
-  if (autocheckout_state_ == AUTOCHECKOUT_NOT_STARTED)
-    return ui::DIALOG_BUTTON_OK | ui::DIALOG_BUTTON_CANCEL;
-  return ui::DIALOG_BUTTON_OK;
+  return ui::DIALOG_BUTTON_OK | ui::DIALOG_BUTTON_CANCEL;
 }
 
 bool AutofillDialogControllerImpl::IsDialogButtonEnabled(
     ui::DialogButton button) const {
   if (button == ui::DIALOG_BUTTON_OK) {
     if (IsSubmitPausedOn(wallet::VERIFY_CVV))
       return true;
 
-    if (ShouldShowSpinner())
+    if (ShouldShowSpinner() || is_submitting_)
       return false;
 
-    if (is_submitting_) {
-      return autocheckout_state_ == AUTOCHECKOUT_SUCCESS ||
-             autocheckout_state_ == AUTOCHECKOUT_ERROR;
-    }
-
     return true;
   }
 
   DCHECK_EQ(ui::DIALOG_BUTTON_CANCEL, button);
   return !is_submitting_ || IsSubmitPausedOn(wallet::VERIFY_CVV);
 }
 
 DialogOverlayState AutofillDialogControllerImpl::GetDialogOverlay() const {
   bool show_wallet_interstitial = IsPayingWithWallet() && is_submitting_ &&
       !IsSubmitPausedOn(wallet::VERIFY_CVV) &&
@@ skipping 420 matching lines @@
   }
 
   gfx::Image icon;
   account_chooser_model_.GetIconAt(
       account_chooser_model_.GetIndexOfCommandId(
           account_chooser_model_.checked_item()),
       &icon);
   return icon;
 }
 
-bool AutofillDialogControllerImpl::ShouldShowDetailArea() const {
-  // Hide the detail area when Autocheckout is running or there was an error (as
-  // there's nothing they can do after an error but cancel).
-  return autocheckout_state_ == AUTOCHECKOUT_NOT_STARTED;
-}
-
-bool AutofillDialogControllerImpl::ShouldShowProgressBar() const {
-  // Show the progress bar while Autocheckout is running but hide it on errors,
-  // as there's no use leaving it up if the flow has failed.
-  return autocheckout_state_ == AUTOCHECKOUT_IN_PROGRESS;
-}
-
 gfx::Image AutofillDialogControllerImpl::ButtonStripImage() const {
-  if (ShouldShowDetailArea() && IsPayingWithWallet()) {
+  if (IsPayingWithWallet()) {
     return ui::ResourceBundle::GetSharedInstance().GetImageNamed(
         IDR_WALLET_LOGO);
   }
 
   return gfx::Image();
 }
 
 string16 AutofillDialogControllerImpl::LabelForSection(DialogSection section)
     const {
   switch (section) {
@@ skipping 540 matching lines @@
     return ui::ResourceBundle::GetSharedInstance().GetImageNamed(
         IDR_PRODUCT_LOGO_NAME_48);
   }
 
   return gfx::Image();
 }
 
 void AutofillDialogControllerImpl::ViewClosed() {
   GetManager()->RemoveObserver(this);
 
-  // TODO(ahutter): Once a user can cancel Autocheckout mid-flow, log that
-  // metric here.
-
   // Called from here rather than in ~AutofillDialogControllerImpl as this
   // relies on virtual methods that change to their base class in the dtor.
   MaybeShowCreditCardBubble();
 
   delete this;
 }
 
 std::vector<DialogNotification> AutofillDialogControllerImpl::
     CurrentNotifications() {
   std::vector<DialogNotification> notifications;
@@ skipping 25 matching lines @@
             IDS_AUTOFILL_DIALOG_COMPLETE_WITHOUT_WALLET,
             account_chooser_model_.wallet_error_message())));
   }
 
   if (IsSubmitPausedOn(wallet::VERIFY_CVV)) {
     notifications.push_back(DialogNotification(
         DialogNotification::REQUIRED_ACTION,
         l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_VERIFY_CVV)));
   }
 
-  if (autocheckout_state_ == AUTOCHECKOUT_ERROR) {
-    notifications.push_back(DialogNotification(
-        DialogNotification::AUTOCHECKOUT_ERROR,
-        l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_AUTOCHECKOUT_ERROR)));
-  }
-
-  if (autocheckout_state_ == AUTOCHECKOUT_SUCCESS) {
-    notifications.push_back(DialogNotification(
-        DialogNotification::AUTOCHECKOUT_SUCCESS,
-        l10n_util::GetStringUTF16(IDS_AUTOFILL_DIALOG_AUTOCHECKOUT_SUCCESS)));
-  }
-
   if (!wallet_server_validation_recoverable_) {
     notifications.push_back(DialogNotification(
         DialogNotification::REQUIRED_ACTION,
         l10n_util::GetStringUTF16(
             IDS_AUTOFILL_DIALOG_FAILED_TO_SAVE_WALLET_DATA)));
   }
 
   if (choose_another_instrument_or_address_) {
     notifications.push_back(DialogNotification(
         DialogNotification::REQUIRED_ACTION,
         l10n_util::GetStringUTF16(
             IDS_AUTOFILL_DIALOG_CHOOSE_DIFFERENT_WALLET_INSTRUMENT)));
   }
 
-  if (should_show_wallet_promo_ && ShouldShowDetailArea() &&
-      notifications.empty()) {
+  if (should_show_wallet_promo_ && notifications.empty()) {
     if (IsPayingWithWallet() && HasCompleteWallet()) {
       notifications.push_back(DialogNotification(
           DialogNotification::EXPLANATORY_MESSAGE,
           l10n_util::GetStringUTF16(
               IDS_AUTOFILL_DIALOG_DETAILS_FROM_WALLET)));
     } else if ((IsPayingWithWallet() && !HasCompleteWallet()) ||
                has_shown_wallet_usage_confirmation_) {
       DialogNotification notification(
           DialogNotification::WALLET_USAGE_CONFIRMATION,
           l10n_util::GetStringUTF16(
@@ skipping 55 matching lines @@
 void AutofillDialogControllerImpl::OverlayButtonPressed() {
   DCHECK(is_submitting_);
   DCHECK(full_wallet_);
   profile_->GetPrefs()->SetBoolean(::prefs::kAutofillDialogHasPaidWithWallet,
                                    true);
   FinishSubmit();
 }
 
 bool AutofillDialogControllerImpl::OnCancel() {
   HidePopup();
-  if (autocheckout_state_ == AUTOCHECKOUT_NOT_STARTED && !is_submitting_)
+  if (!is_submitting_)
     LogOnCancelMetrics();
-  if (autocheckout_state_ == AUTOCHECKOUT_IN_PROGRESS) {
-    GetMetricLogger().LogAutocheckoutDuration(
-        base::Time::Now() - autocheckout_started_timestamp_,
-        AutofillMetrics::AUTOCHECKOUT_CANCELLED);
-  }
   callback_.Run(NULL, std::string());
   return true;
 }
 
 bool AutofillDialogControllerImpl::OnAccept() {
-  // If autocheckout has already started, the only thing left to do is to
-  // close the dialog.
-  if (autocheckout_state_ != AUTOCHECKOUT_NOT_STARTED)
-    return true;
-
   choose_another_instrument_or_address_ = false;
   wallet_server_validation_recoverable_ = true;
   HidePopup();
-  if (IsPayingWithWallet()) {
-    bool has_proxy_card_step = false;
-    for (size_t i = 0; i < steps_.size(); ++i) {
-      if (steps_[i].type() == AUTOCHECKOUT_STEP_PROXY_CARD) {
-        has_proxy_card_step = true;
-        break;
-      }
-    }
-    if (!has_proxy_card_step) {
-      steps_.insert(steps_.begin(),
-                    DialogAutocheckoutStep(AUTOCHECKOUT_STEP_PROXY_CARD,
-                                           AUTOCHECKOUT_STEP_UNSTARTED));
-    }
-  }
-
-  if (GetDialogType() == DIALOG_TYPE_AUTOCHECKOUT)
-    DeemphasizeRenderView();
 
   SetIsSubmitting(true);
   if (IsSubmitPausedOn(wallet::VERIFY_CVV)) {
     DCHECK(!active_instrument_id_.empty());
     GetWalletClient()->AuthenticateInstrument(
         active_instrument_id_,
         UTF16ToUTF8(view_->GetCvc()));
   } else if (IsPayingWithWallet()) {
     // TODO(dbeam): disallow interacting with the dialog while submitting.
     // http://crbug.com/230932
@@ skipping 164 matching lines @@
 }
 
 void AutofillDialogControllerImpl::OnDidGetFullWallet(
     scoped_ptr<wallet::FullWallet> full_wallet) {
   DCHECK(is_submitting_ && IsPayingWithWallet());
   ScopedViewUpdates updates(view_.get());
 
   full_wallet_ = full_wallet.Pass();
 
   if (full_wallet_->required_actions().empty()) {
-    UpdateAutocheckoutStep(AUTOCHECKOUT_STEP_PROXY_CARD,
-                           AUTOCHECKOUT_STEP_COMPLETED);
     FinishSubmit();
     return;
   }
 
-  SetAutocheckoutState(AUTOCHECKOUT_NOT_STARTED);
-
   switch (full_wallet_->required_actions()[0]) {
     case wallet::CHOOSE_ANOTHER_INSTRUMENT_OR_ADDRESS:
       choose_another_instrument_or_address_ = true;
       SetIsSubmitting(false);
       GetWalletItems();
       view_->UpdateNotificationArea();
       view_->UpdateButtonStrip();
       break;
 
     case wallet::VERIFY_CVV:
@@ skipping 150 matching lines @@
     content::WebContents* contents,
     const FormData& form_structure,
     const GURL& source_url,
     const DialogType dialog_type,
     const base::Callback<void(const FormStructure*,
                               const std::string&)>& callback)
     : WebContentsObserver(contents),
       profile_(Profile::FromBrowserContext(contents->GetBrowserContext())),
       initial_user_state_(AutofillMetrics::DIALOG_USER_STATE_UNKNOWN),
       dialog_type_(dialog_type),
-      form_structure_(form_structure, std::string()),
+      form_structure_(form_structure),
       invoked_from_same_origin_(true),
       source_url_(source_url),
       callback_(callback),
       account_chooser_model_(this, profile_->GetPrefs(), metric_logger_,
                              dialog_type),
       wallet_client_(profile_->GetRequestContext(), this),
       suggested_email_(this),
       suggested_cc_(this),
       suggested_billing_(this),
       suggested_cc_billing_(this),
       suggested_shipping_(this),
       cares_about_shipping_(true),
       input_showing_popup_(NULL),
       weak_ptr_factory_(this),
       should_show_wallet_promo_(!profile_->GetPrefs()->GetBoolean(
           ::prefs::kAutofillDialogHasPaidWithWallet)),
       has_shown_wallet_usage_confirmation_(false),
       has_accepted_legal_documents_(false),
       is_submitting_(false),
       choose_another_instrument_or_address_(false),
       wallet_server_validation_recoverable_(true),
       data_was_passed_back_(false),
-      autocheckout_state_(AUTOCHECKOUT_NOT_STARTED),
-      was_ui_latency_logged_(false),
-      deemphasized_render_view_(false) {
+      was_ui_latency_logged_(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_);
@@ skipping 73 matching lines @@
   GetWalletClient()->CancelRequests();
   LogDialogLatencyToShow();
 }
 
 void AutofillDialogControllerImpl::DisableWallet(
     wallet::WalletClient::ErrorType error_type) {
   signin_helper_.reset();
   wallet_items_.reset();
   wallet_errors_.clear();
   GetWalletClient()->CancelRequests();
-  SetAutocheckoutState(AUTOCHECKOUT_NOT_STARTED);
-  for (std::vector<DialogAutocheckoutStep>::iterator it = steps_.begin();
-      it != steps_.end(); ++it) {
-    if (it->type() == AUTOCHECKOUT_STEP_PROXY_CARD) {
-      steps_.erase(it);
-      break;
-    }
-  }
   SetIsSubmitting(false);
   account_chooser_model_.SetHadWalletError(WalletErrorMessage(error_type));
 }
 
 void AutofillDialogControllerImpl::SuggestionsUpdated() {
   ScopedViewUpdates updates(view_.get());
 
   const DetailOutputMap snapshot = TakeUserInputSnapshot();
 
   suggested_email_.Reset();
@@ skipping 559 matching lines @@
   }
 
   const wallet::Address* active_address = ActiveShippingAddress();
   if (!IsManuallyEditingSection(SECTION_SHIPPING) &&
       !ShouldUseBillingForShipping() &&
       IsShippingAddressRequired()) {
     active_address_id_ = active_address->object_id();
     DCHECK(!active_address_id_.empty());
   }
 
-  if (GetDialogType() == DIALOG_TYPE_AUTOCHECKOUT) {
-    DCHECK_EQ(AUTOCHECKOUT_NOT_STARTED, autocheckout_state_);
-    SetAutocheckoutState(AUTOCHECKOUT_IN_PROGRESS);
-  }
-
   scoped_ptr<wallet::Instrument> inputted_instrument =
       CreateTransientInstrument();
   if (inputted_instrument && IsEditingExistingData(SECTION_CC_BILLING)) {
     inputted_instrument->set_object_id(active_instrument->object_id());
     DCHECK(!inputted_instrument->object_id().empty());
   }
 
   scoped_ptr<wallet::Address> inputted_address;
   if (active_address_id_.empty() && IsShippingAddressRequired()) {
     if (ShouldUseBillingForShipping()) {
@@ skipping 64 matching lines @@
 void AutofillDialogControllerImpl::GetFullWallet() {
   DCHECK(is_submitting_);
   DCHECK(IsPayingWithWallet());
   DCHECK(wallet_items_);
   DCHECK(!active_instrument_id_.empty());
   DCHECK(!active_address_id_.empty() || !IsShippingAddressRequired());
 
   std::vector<wallet::WalletClient::RiskCapability> capabilities;
   capabilities.push_back(wallet::WalletClient::VERIFY_CVC);
 
-  UpdateAutocheckoutStep(AUTOCHECKOUT_STEP_PROXY_CARD,
-                         AUTOCHECKOUT_STEP_STARTED);
-
   GetWalletClient()->GetFullWallet(wallet::WalletClient::FullWalletRequest(
       active_instrument_id_,
       active_address_id_,
       source_url_,
       wallet_items_->google_transaction_id(),
       capabilities,
       wallet_items_->HasRequiredAction(wallet::SETUP_WALLET)));
 }
 
 void AutofillDialogControllerImpl::HandleSaveOrUpdateRequiredActions(
     const std::vector<wallet::RequiredAction>& required_actions) {
   DCHECK(!required_actions.empty());
 
   // TODO(ahutter): Invesitigate if we need to support more generic actions on
   // this call such as GAIA_AUTH. See crbug.com/243457.
   for (std::vector<wallet::RequiredAction>::const_iterator iter =
            required_actions.begin();
        iter != required_actions.end(); ++iter) {
     if (*iter != wallet::INVALID_FORM_FIELD) {
       // TODO(dbeam): handle this more gracefully.
       DisableWallet(wallet::WalletClient::UNKNOWN_ERROR);
     }
   }
-  SetAutocheckoutState(AUTOCHECKOUT_NOT_STARTED);
   SetIsSubmitting(false);
 }
 
 void AutofillDialogControllerImpl::FinishSubmit() {
   if (IsPayingWithWallet() &&
       !profile_->GetPrefs()->GetBoolean(
           ::prefs::kAutofillDialogHasPaidWithWallet)) {
     if (GetDialogType() == DIALOG_TYPE_REQUEST_AUTOCOMPLETE) {
       // To get past this point, the view must call back OverlayButtonPressed.
 #if defined(TOOLKIT_VIEWS)
@@ skipping 48 matching lines @@
   // stop trying to pay with Wallet on future runs of the dialog. On the other
   // hand, if there was an error that prevented the user from having the choice
   // of using Wallet, leave the pref alone.
   if (!account_chooser_model_.HadWalletError() &&
       account_chooser_model_.HasAccountsToChoose()) {
     profile_->GetPrefs()->SetBoolean(
         ::prefs::kAutofillDialogPayWithoutWallet,
         !account_chooser_model_.WalletIsSelected());
   }
 
-  if (GetDialogType() == DIALOG_TYPE_AUTOCHECKOUT) {
-    // Stop observing PersonalDataManager to avoid the dialog redrawing while
-    // in an Autocheckout flow.
-    GetManager()->RemoveObserver(this);
-    autocheckout_started_timestamp_ = base::Time::Now();
-    SetAutocheckoutState(AUTOCHECKOUT_IN_PROGRESS);
-  }
-
   LogOnFinishSubmitMetrics();
 
   // Callback should be called as late as possible.
   callback_.Run(&form_structure_, !wallet_items_ ? std::string() :
       wallet_items_->google_transaction_id());
   data_was_passed_back_ = true;
 
   // This might delete us.
   if (GetDialogType() == DIALOG_TYPE_REQUEST_AUTOCOMPLETE)
     Hide();
@@ skipping 130 matching lines @@
 void AutofillDialogControllerImpl::LogDialogLatencyToShow() {
   if (was_ui_latency_logged_)
     return;
 
   GetMetricLogger().LogDialogLatencyToShow(
       GetDialogType(),
       base::Time::Now() - dialog_shown_timestamp_);
   was_ui_latency_logged_ = true;
 }
 
-void AutofillDialogControllerImpl::SetAutocheckoutState(
-    AutocheckoutState autocheckout_state) {
-  if (autocheckout_state_ == autocheckout_state)
-    return;
-
-  autocheckout_state_ = autocheckout_state;
-  if (view_) {
-    ScopedViewUpdates updates(view_.get());
-    view_->UpdateDetailArea();
-    view_->UpdateButtonStrip();
-    view_->UpdateAutocheckoutStepsArea();
-    view_->UpdateNotificationArea();
-  }
-}
-
-void AutofillDialogControllerImpl::DeemphasizeRenderView() {
-  web_contents()->GetRenderViewHost()->Send(
-      new ChromeViewMsg_SetVisuallyDeemphasized(
-          web_contents()->GetRenderViewHost()->GetRoutingID(), true));
-  deemphasized_render_view_ = true;
-}
-
 AutofillMetrics::DialogInitialUserStateMetric
     AutofillDialogControllerImpl::GetInitialUserState() const {
   // Consider a user to be an Autofill user if the user has any credit cards
   // or addresses saved. Check that the item count is greater than 2 because
   // an "empty" menu still has the "add new" menu item and "manage" menu item.
   const bool has_autofill_profiles =
       suggested_cc_.GetItemCount() > 2 ||
       suggested_billing_.GetItemCount() > 2;
 
   if (SignedInState() != SIGNED_IN) {
@@ skipping 43 matching lines @@
         GetValueFromSection(SECTION_EMAIL, EMAIL_ADDRESS));
 
     ShowNewCreditCardBubble(newly_saved_card_.Pass(),
                             billing_profile.Pass());
     return;
   }
 
   if (!full_wallet_ || !full_wallet_->billing_address())
     return;
 
-  // Don't show GeneratedCardBubble if Autocheckout failed.
-  if (GetDialogType() == DIALOG_TYPE_AUTOCHECKOUT &&
-      autocheckout_state_ != AUTOCHECKOUT_SUCCESS) {
-    return;
-  }
-
   base::string16 backing_last_four;
   if (ActiveInstrument()) {
     backing_last_four = ActiveInstrument()->TypeAndLastFourDigits();
   } else {
     DetailOutputMap output;
     view_->GetUserInput(SECTION_CC_BILLING, &output);
     CreditCard card;
     GetBillingInfoFromOutputs(output, &card, NULL, NULL);
     backing_last_four = card.TypeAndLastFourDigits();
   }
 #if !defined(OS_ANDROID)
   GeneratedCreditCardBubbleController::Show(
       web_contents(),
       backing_last_four,
       full_wallet_->TypeAndLastFourDigits());
 #endif
 }
 
 }  // namespace autofill