Remove autocheckout code.

components/autofill/core/browser/autofill_manager.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 "components/autofill/core/browser/autofill_manager.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
-#include "components/autofill/content/browser/autocheckout/whitelist_manager.h"
-#include "components/autofill/content/browser/autocheckout_manager.h"
 #include "components/autofill/core/browser/autocomplete_history_manager.h"
 #include "components/autofill/core/browser/autofill_data_model.h"
 #include "components/autofill/core/browser/autofill_driver.h"
 #include "components/autofill/core/browser/autofill_external_delegate.h"
 #include "components/autofill/core/browser/autofill_field.h"
 #include "components/autofill/core/browser/autofill_manager_delegate.h"
 #include "components/autofill/core/browser/autofill_manager_test_delegate.h"
 #include "components/autofill/core/browser/autofill_metrics.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_type.h"
@@ skipping 148 matching lines @@
     AutofillDriver* driver,
     autofill::AutofillManagerDelegate* delegate,
     const std::string& app_locale,
     AutofillDownloadManagerState enable_download_manager)
     : driver_(driver),
       manager_delegate_(delegate),
       app_locale_(app_locale),
       personal_data_(delegate->GetPersonalDataManager()),
       autocomplete_history_manager_(
           new AutocompleteHistoryManager(driver, delegate)),
-      autocheckout_manager_(this),
       metric_logger_(new AutofillMetrics),
       has_logged_autofill_enabled_(false),
       has_logged_address_suggestions_count_(false),
       did_show_suggestions_(false),
       user_did_type_(false),
       user_did_autofill_(false),
       user_did_edit_autofilled_field_(false),
       external_delegate_(NULL),
       test_delegate_(NULL),
       weak_ptr_factory_(this) {
@@ skipping 51 matching lines @@
     return false;
 
   if (driver_->GetWebContents()->GetBrowserContext()->IsOffTheRecord())
     return false;
 
   // Don't save data that was submitted through JavaScript.
   if (!form.user_submitted)
     return false;
 
   // Grab a copy of the form data.
-  scoped_ptr<FormStructure> submitted_form(
-      new FormStructure(form, GetAutocheckoutURLPrefix()));
+  scoped_ptr<FormStructure> submitted_form(new FormStructure(form));
 
   // Disregard forms that we wouldn't ever autofill in the first place.
   if (!submitted_form->ShouldBeParsed(true))
     return false;
 
   // Ignore forms not present in our cache.  These are typically forms with
   // wonky JavaScript that also makes them not auto-fillable.
   FormStructure* cached_submitted_form;
   if (!FindCachedForm(form, &cached_submitted_form))
     return false;
 
   submitted_form->UpdateFromCache(*cached_submitted_form);
-  // Don't prompt the user to save data entered by Autocheckout.
-  if (submitted_form->IsAutofillable(true) &&
-      !submitted_form->filled_by_autocheckout())
+  if (submitted_form->IsAutofillable(true))
     ImportFormData(*submitted_form);
 
   // Only upload server statistics and UMA metrics if at least some local data
   // is available to use as a baseline.
   const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
   const std::vector<CreditCard*>& credit_cards =
       personal_data_->GetCreditCards();
   if (!profiles.empty() || !credit_cards.empty()) {
     // Copy the profile and credit card data, so that it can be accessed on a
     // separate thread.
@@ skipping 29 matching lines @@
                    timestamp));
   }
 
   return true;
 }
 
 void AutofillManager::OnFormsSeen(const std::vector<FormData>& forms,
                                   const TimeTicks& timestamp,
                                   autofill::FormsSeenState state) {
   bool is_post_document_load = state == autofill::DYNAMIC_FORMS_SEEN;
-  bool has_more_forms = state == autofill::PARTIAL_FORMS_SEEN;
-  // If new forms were added dynamically, and the autocheckout manager
-  // doesn't tell us to ignore ajax on this page, treat as a new page.
-  if (is_post_document_load) {
-    if (autocheckout_manager_.ShouldIgnoreAjax())
-      return;
-
+  // If new forms were added dynamically, treat as a new page.
+  if (is_post_document_load)
     Reset();
-  }
 
   RenderViewHost* host = driver_->GetWebContents()->GetRenderViewHost();
   if (!host)
     return;
 
-  if (!GetAutocheckoutURLPrefix().empty()) {
-    // If whitelisted URL, fetch all the forms.
-    if (has_more_forms)
-      host->Send(new AutofillMsg_GetAllForms(host->GetRoutingID()));
-    if (!is_post_document_load) {
-      host->Send(
-          new AutofillMsg_AutocheckoutSupported(host->GetRoutingID()));
-    }
-    // Now return early, as OnFormsSeen will get called again with all forms.
-    if (has_more_forms)
-      return;
-  }
-
-  autocheckout_manager_.OnFormsSeen();
   bool enabled = IsAutofillEnabled();
   if (!has_logged_autofill_enabled_) {
     metric_logger_->LogIsAutofillEnabledAtPageLoad(enabled);
     has_logged_autofill_enabled_ = true;
   }
 
   if (!enabled)
     return;
 
   forms_loaded_timestamp_ = timestamp;
   ParseForms(forms);
 }
 
 void AutofillManager::OnTextFieldDidChange(const FormData& form,
                                            const FormFieldData& field,
                                            const TimeTicks& timestamp) {
   FormStructure* form_structure = NULL;
   AutofillField* autofill_field = NULL;
   if (!GetCachedFormAndField(form, field, &form_structure, &autofill_field))
     return;
 
   if (!user_did_type_) {
-    autocheckout_manager_.set_should_show_bubble(false);
     user_did_type_ = true;
     metric_logger_->LogUserHappinessMetric(AutofillMetrics::USER_DID_TYPE);
   }
 
   if (autofill_field->is_autofilled) {
     autofill_field->is_autofilled = false;
     metric_logger_->LogUserHappinessMetric(
         AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD);
 
     if (!user_did_edit_autofilled_field_) {
       user_did_edit_autofilled_field_ = true;
       metric_logger_->LogUserHappinessMetric(
           AutofillMetrics::USER_DID_EDIT_AUTOFILLED_FIELD_ONCE);
     }
   }
 
   UpdateInitialInteractionTimestamp(timestamp);
 }
 
 void AutofillManager::OnQueryFormFieldAutofill(int query_id,
                                                const FormData& form,
                                                const FormFieldData& field,
                                                const gfx::RectF& bounding_box,
                                                bool display_warning) {
-  if (autocheckout_manager_.is_autocheckout_bubble_showing())
-    return;
-
   std::vector<base::string16> values;
   std::vector<base::string16> labels;
   std::vector<base::string16> icons;
   std::vector<int> unique_ids;
 
   external_delegate_->OnQuery(query_id,
                               form,
                               field,
                               bounding_box,
                               display_warning);
@@ skipping 190 matching lines @@
           AutofillMetrics::SUGGESTIONS_SHOWN_ONCE);
     }
   }
 }
 
 void AutofillManager::OnHideAutofillUI() {
   if (!IsAutofillEnabled())
     return;
 
   manager_delegate_->HideAutofillPopup();
-  manager_delegate_->HideAutocheckoutBubble();
 }
 
 void AutofillManager::RemoveAutofillProfileOrCreditCard(int unique_id) {
   const AutofillDataModel* data_model = NULL;
   size_t variant = 0;
   if (!GetProfileOrCreditCard(unique_id, &data_model, &variant)) {
     NOTREACHED();
     return;
   }
 
@@ skipping 98 matching lines @@
     ReturnAutocompleteResult(WebFormElement::AutocompleteResultErrorCancel,
                              FormData());
   } else {
     ReturnAutocompleteResult(WebFormElement::AutocompleteResultSuccess,
                              result->ToFormData());
   }
 }
 
 void AutofillManager::OnLoadedServerPredictions(
     const std::string& response_xml) {
-  scoped_ptr<autofill::AutocheckoutPageMetaData> page_meta_data(
-      new autofill::AutocheckoutPageMetaData());
-
   // Parse and store the server predictions.
   FormStructure::ParseQueryResponse(response_xml,
                                     form_structures_.get(),
-                                    page_meta_data.get(),
                                     *metric_logger_);
 
-  if (page_meta_data->IsInAutofillableFlow()) {
-    RenderViewHost* host = driver_->GetWebContents()->GetRenderViewHost();
-    if (host)
-      host->Send(new AutofillMsg_AutocheckoutSupported(host->GetRoutingID()));
-  }
-
-  // TODO(ahutter): Remove this once Autocheckout is implemented on other
-  // platforms. See http://crbug.com/173416.
-#if defined(TOOLKIT_VIEWS)
-  if (!GetAutocheckoutURLPrefix().empty())
-    autocheckout_manager_.OnLoadedPageMetaData(page_meta_data.Pass());
-#endif  // #if defined(TOOLKIT_VIEWS)
-
   // If the corresponding flag is set, annotate forms with the predicted types.
   driver_->SendAutofillTypePredictionsToRenderer(form_structures_.get());
 }
 
 void AutofillManager::OnDidEndTextFieldEditing() {
   external_delegate_->DidEndTextFieldEditing();
 }
 
-void AutofillManager::OnAutocheckoutPageCompleted(
-    autofill::AutocheckoutStatus status) {
-  autocheckout_manager_.OnAutocheckoutPageCompleted(status);
-}
-
-std::string AutofillManager::GetAutocheckoutURLPrefix() const {
-  if (!driver_->GetWebContents())
-    return std::string();
-
-  autofill::autocheckout::WhitelistManager* whitelist_manager =
-      manager_delegate_->GetAutocheckoutWhitelistManager();
-
-  return whitelist_manager ? whitelist_manager->GetMatchedURLPrefix(
-      driver_->GetWebContents()->GetURL()) : std::string();
-}
-
 bool AutofillManager::IsAutofillEnabled() const {
   return manager_delegate_->GetPrefs()->GetBoolean(prefs::kAutofillEnabled);
 }
 
 void AutofillManager::ImportFormData(const FormStructure& submitted_form) {
   const CreditCard* imported_credit_card;
   if (!personal_data_->ImportFormData(submitted_form, &imported_credit_card))
     return;
 
   // If credit card information was submitted, we need to confirm whether to
@@ skipping 18 matching lines @@
     const TimeTicks& submission_time) {
   submitted_form->LogQualityMetrics(*metric_logger_,
                                     load_time,
                                     interaction_time,
                                     submission_time);
 
   if (submitted_form->ShouldBeCrowdsourced())
     UploadFormData(*submitted_form);
 }
 
-void AutofillManager::OnMaybeShowAutocheckoutBubble(
-    const FormData& form,
-    const gfx::RectF& bounding_box) {
-  if (!IsAutofillEnabled())
-    return;
-
-  // Don't show bubble if corresponding FormStructure doesn't have anything to
-  // autofill.
-  FormStructure* cached_form;
-  if (!FindCachedForm(form, &cached_form))
-    return;
-
-  // Don't offer Autocheckout bubble if Autofill server is not aware of this
-  // form in the context of Autocheckout experiment.
-  if (!HasServerSpecifiedFieldTypes(*cached_form))
-    return;
-
-  autocheckout_manager_.MaybeShowAutocheckoutBubble(form.origin, bounding_box);
-}
-
 void AutofillManager::UploadFormData(const FormStructure& submitted_form) {
   if (!download_manager_)
     return;
 
   // Check if the form is among the forms that were recently auto-filled.
   bool was_autofilled = false;
   std::string form_signature = submitted_form.FormSignature();
   for (std::list<std::string>::const_iterator it =
            autofilled_form_signatures_.begin();
        it != autofilled_form_signatures_.end() && !was_autofilled;
@@ skipping 24 matching lines @@
 
 AutofillManager::AutofillManager(AutofillDriver* driver,
                                  autofill::AutofillManagerDelegate* delegate,
                                  PersonalDataManager* personal_data)
     : driver_(driver),
       manager_delegate_(delegate),
       app_locale_("en-US"),
       personal_data_(personal_data),
       autocomplete_history_manager_(
           new AutocompleteHistoryManager(driver, delegate)),
-      autocheckout_manager_(this),
       metric_logger_(new AutofillMetrics),
       has_logged_autofill_enabled_(false),
       has_logged_address_suggestions_count_(false),
       did_show_suggestions_(false),
       user_did_type_(false),
       user_did_autofill_(false),
       user_did_edit_autofilled_field_(false),
       external_delegate_(NULL),
       test_delegate_(NULL),
       weak_ptr_factory_(this) {
@@ skipping 79 matching lines @@
 }
 
 bool AutofillManager::GetCachedFormAndField(const FormData& form,
                                             const FormFieldData& field,
                                             FormStructure** form_structure,
                                             AutofillField** autofill_field) {
   // Find the FormStructure that corresponds to |form|.
   // If we do not have this form in our cache but it is parseable, we'll add it
   // in the call to |UpdateCachedForm()|.
   if (!FindCachedForm(form, form_structure) &&
-      !FormStructure(form, GetAutocheckoutURLPrefix()).ShouldBeParsed(false)) {
+      !FormStructure(form).ShouldBeParsed(false)) {
     return false;
   }
 
   // Update the cached form to reflect any dynamic changes to the form data, if
   // necessary.
   if (!UpdateCachedForm(form, *form_structure, form_structure))
     return false;
 
   // No data to return if there are no auto-fillable fields.
   if (!(*form_structure)->autofill_count())
@@ skipping 26 matching lines @@
     needs_update = *cached_form->field(i) != live_form.fields[i];
   }
 
   if (!needs_update)
     return true;
 
   if (form_structures_.size() >= kMaxFormCacheSize)
     return false;
 
   // Add the new or updated form to our cache.
-  form_structures_.push_back(
-      new FormStructure(live_form, GetAutocheckoutURLPrefix()));
+  form_structures_.push_back(new FormStructure(live_form));
   *updated_form = *form_structures_.rbegin();
   (*updated_form)->DetermineHeuristicTypes(*metric_logger_);
 
   // If we have cached data, propagate it to the updated form.
   if (cached_form) {
     std::map<base::string16, const AutofillField*> cached_fields;
     for (size_t i = 0; i < cached_form->field_count(); ++i) {
       const AutofillField* field = cached_form->field(i);
       cached_fields[field->unique_name()] = field;
     }
@@ skipping 55 matching lines @@
   personal_data_->GetCreditCardSuggestions(
       type, field.value, values, labels, icons, &guid_pairs);
 
   for (size_t i = 0; i < guid_pairs.size(); ++i) {
     unique_ids->push_back(PackGUIDs(guid_pairs[i], GUIDPair(std::string(), 0)));
   }
 }
 
 void AutofillManager::ParseForms(const std::vector<FormData>& forms) {
   std::vector<FormStructure*> non_queryable_forms;
-  std::string autocheckout_url_prefix = GetAutocheckoutURLPrefix();
   for (std::vector<FormData>::const_iterator iter = forms.begin();
        iter != forms.end(); ++iter) {
-    scoped_ptr<FormStructure> form_structure(
-        new FormStructure(*iter, autocheckout_url_prefix));
+    scoped_ptr<FormStructure> form_structure(new FormStructure(*iter));
     if (!form_structure->ShouldBeParsed(false))
       continue;
 
     form_structure->DetermineHeuristicTypes(*metric_logger_);
 
     // Set aside forms with method GET or author-specified types, so that they
     // are not included in the query to the server.
     if (form_structure->ShouldBeCrowdsourced())
       form_structures_.push_back(form_structure.release());
     else
       non_queryable_forms.push_back(form_structure.release());
   }
 
-  if (form_structures_.empty()) {
-    // Call OnLoadedPageMetaData with no page metadata immediately if there is
-    // no form in the page. This give |autocheckout_manager| a chance to
-    // terminate Autocheckout and send Autocheckout status.
-    autocheckout_manager_.OnLoadedPageMetaData(
-        scoped_ptr<autofill::AutocheckoutPageMetaData>());
-  } else if (download_manager_) {
+  if (!form_structures_.empty() && download_manager_) {
     // Query the server if we have at least one of the forms were parsed.
     download_manager_->StartQueryRequest(form_structures_.get(),
                                         *metric_logger_);
   }
 
   for (std::vector<FormStructure*>::const_iterator iter =
            non_queryable_forms.begin();
        iter != non_queryable_forms.end(); ++iter) {
     form_structures_.push_back(*iter);
   }
@@ skipping 65 matching lines @@
 
 void AutofillManager::UpdateInitialInteractionTimestamp(
     const TimeTicks& interaction_timestamp) {
   if (initial_interaction_timestamp_.is_null() ||
       interaction_timestamp < initial_interaction_timestamp_) {
     initial_interaction_timestamp_ = interaction_timestamp;
   }
 }
 
 }  // namespace autofill