Remove autocheckout code.

components/autofill/core/browser/form_structure.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/form_structure.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
-#include "components/autofill/content/browser/autocheckout_page_meta_data.h"
 #include "components/autofill/core/browser/autofill_metrics.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/autofill_xml_parser.h"
 #include "components/autofill/core/browser/field_types.h"
 #include "components/autofill/core/browser/form_field.h"
 #include "components/autofill/core/common/autofill_constants.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/form_data_predictions.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/autofill/core/common/form_field_data_predictions.h"
@@ skipping 11 matching lines @@
 const char kAttributeAutofillType[] = "autofilltype";
 const char kAttributeClientVersion[] = "clientversion";
 const char kAttributeDataPresent[] = "datapresent";
 const char kAttributeFieldID[] = "fieldid";
 const char kAttributeFieldType[] = "fieldtype";
 const char kAttributeFormSignature[] = "formsignature";
 const char kAttributeName[] = "name";
 const char kAttributeSignature[] = "signature";
 const char kAttributeUrlprefixSignature[] = "urlprefixsignature";
 const char kAcceptedFeaturesExperiment[] = "e"; // e=experiments
-const char kAcceptedFeaturesAutocheckoutExperiment[] = "a,e"; // a=autocheckout
 const char kClientVersion[] = "6.1.1715.1442/en (GGLL)";
 const char kXMLDeclaration[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
 const char kXMLElementAutofillQuery[] = "autofillquery";
 const char kXMLElementAutofillUpload[] = "autofillupload";
 const char kXMLElementFieldAssignments[] = "fieldassignments";
 const char kXMLElementField[] = "field";
 const char kXMLElementFields[] = "fields";
 const char kXMLElementForm[] = "form";
 const char kBillingMode[] = "billing";
 const char kShippingMode[] = "shipping";
@@ skipping 255 matching lines @@
   if (status != U_ZERO_ERROR) {
     DVLOG(1) << "Couldn't strip digits in " << UTF16ToUTF8(input);
     return UTF16ToUTF8(input);
   }
 
   return return_string;
 }
 
 }  // namespace
 
-FormStructure::FormStructure(const FormData& form,
-                             const std::string& autocheckout_url_prefix)
+FormStructure::FormStructure(const FormData& form)
     : form_name_(form.name),
       source_url_(form.origin),
       target_url_(form.action),
       autofill_count_(0),
       active_field_count_(0),
       upload_required_(USE_UPLOAD_RATES),
       server_experiment_id_("no server response"),
-      has_author_specified_types_(false),
-      autocheckout_url_prefix_(autocheckout_url_prefix),
-      filled_by_autocheckout_(false) {
+      has_author_specified_types_(false) {
   // Copy the form fields.
   std::map<base::string16, size_t> unique_names;
   for (std::vector<FormFieldData>::const_iterator field =
            form.fields.begin();
        field != form.fields.end(); field++) {
 
     if (!ShouldSkipField(*field)) {
       // Add all supported form fields (including with empty names) to the
       // signature.  This is a requirement for Autofill servers.
       form_signature_field_names_.append("&");
@@ skipping 139 matching lines @@
   encoded_xml->clear();
   encoded_signatures->clear();
   encoded_signatures->reserve(forms.size());
 
   // Set up the <autofillquery> element and attributes.
   buzz::XmlElement autofill_request_xml(
       (buzz::QName(kXMLElementAutofillQuery)));
   autofill_request_xml.SetAttr(buzz::QName(kAttributeClientVersion),
                                kClientVersion);
 
-  // autocheckout_url_prefix tells the Autofill server where the forms in the
-  // request came from, and the the Autofill server checks internal status and
-  // decide to enable Autocheckout or not and may return Autocheckout related
-  // data in the response accordingly.
-  // There is no page/frame level object associated with FormStructure that
-  // we could extract URL prefix from. But, all the forms should come from the
-  // same frame, so they should have the same Autocheckout URL prefix. Thus we
-  // use URL prefix from the first form with Autocheckout enabled.
-  std::string autocheckout_url_prefix;
-
   // Some badly formatted web sites repeat forms - detect that and encode only
   // one form as returned data would be the same for all the repeated forms.
   std::set<std::string> processed_forms;
   for (ScopedVector<FormStructure>::const_iterator it = forms.begin();
        it != forms.end();
        ++it) {
     std::string signature((*it)->FormSignature());
     if (processed_forms.find(signature) != processed_forms.end())
       continue;
     processed_forms.insert(signature);
     scoped_ptr<buzz::XmlElement> encompassing_xml_element(
         new buzz::XmlElement(buzz::QName(kXMLElementForm)));
     encompassing_xml_element->SetAttr(buzz::QName(kAttributeSignature),
                                       signature);
 
     if (!(*it)->EncodeFormRequest(FormStructure::QUERY,
                                   encompassing_xml_element.get()))
       continue;  // Malformed form, skip it.
 
-    if ((*it)->IsAutocheckoutEnabled()) {
-      if (autocheckout_url_prefix.empty()) {
-        autocheckout_url_prefix = (*it)->autocheckout_url_prefix_;
-      } else {
-        // Making sure all the forms in the request has the same url_prefix.
-        DCHECK_EQ(autocheckout_url_prefix, (*it)->autocheckout_url_prefix_);
-      }
-    }
-
     autofill_request_xml.AddElement(encompassing_xml_element.release());
     encoded_signatures->push_back(signature);
   }
 
   if (!encoded_signatures->size())
     return false;
 
-  if (autocheckout_url_prefix.empty()) {
-    autofill_request_xml.SetAttr(buzz::QName(kAttributeAcceptedFeatures),
-                                 kAcceptedFeaturesExperiment);
-  } else {
-    autofill_request_xml.SetAttr(buzz::QName(kAttributeAcceptedFeatures),
-                                 kAcceptedFeaturesAutocheckoutExperiment);
-    autofill_request_xml.SetAttr(buzz::QName(kAttributeUrlprefixSignature),
-                                 Hash64Bit(autocheckout_url_prefix));
-  }
+  autofill_request_xml.SetAttr(buzz::QName(kAttributeAcceptedFeatures),
+                               kAcceptedFeaturesExperiment);
 
   // Obtain the XML structure as a string.
   *encoded_xml = kXMLDeclaration;
   *encoded_xml += autofill_request_xml.Str().c_str();
 
   return true;
 }
 
 // static
 void FormStructure::ParseQueryResponse(
     const std::string& response_xml,
     const std::vector<FormStructure*>& forms,
-    autofill::AutocheckoutPageMetaData* page_meta_data,
     const AutofillMetrics& metric_logger) {
   metric_logger.LogServerQueryMetric(AutofillMetrics::QUERY_RESPONSE_RECEIVED);
 
   // Parse the field types from the server response to the query.
   std::vector<AutofillServerFieldInfo> field_infos;
   UploadRequired upload_required;
   std::string experiment_id;
   AutofillQueryXmlParser parse_handler(&field_infos,
                                        &upload_required,
-                                       &experiment_id,
-                                       page_meta_data);
+                                       &experiment_id);
   buzz::XmlParser parser(&parse_handler);
   parser.Parse(response_xml.c_str(), response_xml.length(), true);
   if (!parse_handler.succeeded())
     return;
 
   metric_logger.LogServerQueryMetric(AutofillMetrics::QUERY_RESPONSE_PARSED);
   metric_logger.LogServerExperimentIdForQuery(experiment_id);
 
   bool heuristics_detected_fillable_field = false;
   bool query_response_overrode_heuristics = false;
@@ skipping 99 matching lines @@
     host = source_url_.host();
   }
 
   std::string form_string = scheme + "://" + host + "&" +
                             UTF16ToUTF8(form_name_) +
                             form_signature_field_names_;
 
   return Hash64Bit(form_string);
 }
 
-bool FormStructure::IsAutocheckoutEnabled() const {
-  return !autocheckout_url_prefix_.empty();
-}
-
 bool FormStructure::ShouldSkipField(const FormFieldData& field) const {
-  return (field.is_checkable || field.form_control_type == "password") &&
-      !IsAutocheckoutEnabled();
+  return (field.is_checkable || field.form_control_type == "password");
 }
 
 size_t FormStructure::RequiredFillableFields() const {
-  return IsAutocheckoutEnabled() ? 0 : kRequiredAutofillFields;
+  return kRequiredAutofillFields;
 }

[Ilya Sherman, 2013/08/27 18:57:57]

nit: Seems reasonable to inline this method at this point.

[Raman Kakilate, 2013/08/27 21:52:59]

Done.

 
 bool FormStructure::IsAutofillable(bool require_method_post) const {
   if (autofill_count() < RequiredFillableFields())
     return false;
 
   return ShouldBeParsed(require_method_post);
 }
 
 void FormStructure::UpdateAutofillCount() {
   autofill_count_ = 0;
   for (std::vector<AutofillField*>::const_iterator iter = begin();
        iter != end(); ++iter) {
     AutofillField* field = *iter;
     if (field && field->IsFieldFillable())
       ++autofill_count_;
   }
 }
 
 bool FormStructure::ShouldBeParsed(bool require_method_post) const {
   if (active_field_count() < RequiredFillableFields())
     return false;
 
   // Rule out http(s)://*/search?...
   //  e.g. http://www.google.com/search?q=...
   //       http://search.yahoo.com/search?p=...
   if (target_url_.path() == "/search")
     return false;
 
-  if (!IsAutocheckoutEnabled()) {
-    // Make sure there is at least one text field when Autocheckout is
-    // not enabled.
-    bool has_text_field = false;
-    for (std::vector<AutofillField*>::const_iterator it = begin();
-         it != end() && !has_text_field; ++it) {
-      has_text_field |= (*it)->form_control_type != "select-one";
-    }
-    if (!has_text_field)
-      return false;
+  bool has_text_field = false;
+  for (std::vector<AutofillField*>::const_iterator it = begin();
+       it != end() && !has_text_field; ++it) {
+    has_text_field |= (*it)->form_control_type != "select-one";
   }
+  if (!has_text_field)
+    return false;
 
   return !require_method_post || (method_ == POST);
 }
 
 bool FormStructure::ShouldBeCrowdsourced() const {
-  // Allow all forms in Autocheckout flow to be crowdsourced.
-  return (!has_author_specified_types_ && ShouldBeParsed(true)) ||
-      IsAutocheckoutEnabled();
+  return !has_author_specified_types_ && ShouldBeParsed(true);
 }
 
 void FormStructure::UpdateFromCache(const FormStructure& cached_form) {
   // Map from field signatures to cached fields.
   std::map<std::string, 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->FieldSignature()] = field;
   }
 
@@ skipping 11 matching lines @@
         field->value = base::string16();
       }
 
       field->set_heuristic_type(cached_field->second->heuristic_type());
       field->set_server_type(cached_field->second->server_type());
     }
   }
 
   UpdateAutofillCount();
 
-  filled_by_autocheckout_ = cached_form.filled_by_autocheckout();
   server_experiment_id_ = cached_form.server_experiment_id();
 
   // The form signature should match between query and upload requests to the
   // server. On many websites, form elements are dynamically added, removed, or
   // rearranged via JavaScript between page load and form submission, so we
   // copy over the |form_signature_field_names_| corresponding to the query
   // request.
   DCHECK_EQ(cached_form.form_name_, form_name_);
   DCHECK_EQ(cached_form.source_url_, source_url_);
   DCHECK_EQ(cached_form.target_url_, target_url_);
@@ skipping 454 matching lines @@
        field != fields_.end(); ++field) {
     FieldTypeGroup field_type_group = (*field)->Type().group();
     if (field_type_group == CREDIT_CARD)
       (*field)->set_section((*field)->section() + "-cc");
     else
       (*field)->set_section((*field)->section() + "-default");
   }
 }
 
 }  // namespace autofill