Download autocheckout whitelist and enable autocheckout for whitelisted sites only.

chrome/browser/autofill/form_structure.cc

 // Copyright (c) 2012 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/autofill/form_structure.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 205 matching lines @@
     return PHONE_HOME_NUMBER;
 
   if (autocomplete_type == "email")
     return EMAIL_ADDRESS;
 
   return UNKNOWN_TYPE;
 }
 
 }  // namespace
 
-FormStructure::FormStructure(const FormData& form)
+FormStructure::FormStructure(const FormData& form,
+                             std::string autocheckout_url_prefix)
     : form_name_(form.name),
       source_url_(form.origin),
       target_url_(form.action),
       autofill_count_(0),
       checkable_field_count_(0),
       upload_required_(USE_UPLOAD_RATES),
       server_experiment_id_("no server response"),
       has_author_specified_types_(false),
-      experimental_form_filling_enabled_(
-          CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kEnableExperimentalFormFilling)) {
+      autocheckout_url_prefix_(autocheckout_url_prefix) {
   // Copy the form fields.
   std::map<string16, size_t> unique_names;
   for (std::vector<FormFieldData>::const_iterator field =
            form.fields.begin();
        field != form.fields.end(); field++) {
-    // Skipping checkable elements when flag is not set, else these fields will
-    // interfere with existing field signatures with Autofill servers.
-    // TODO(ramankk): Add checkable elements only on whitelisted pages
-    if (!field->is_checkable || experimental_form_filling_enabled_) {
+    // Skipping checkable elements when autocheckout is not enabled, else
+    // these fields will interfere with existing field signatures with Autofill
+    // servers.
+    if (!field->is_checkable || IsAutocheckoutEnabled()) {
       // Add all supported form fields (including with empty names) to the
       // signature.  This is a requirement for Autofill servers.
       form_signature_field_names_.append("&");
       form_signature_field_names_.append(UTF16ToUTF8(field->name));
     }
 
     // Generate a unique name for this field by appending a counter to the name.
     // Make sure to prepend the counter with a non-numeric digit so that we are
     // guaranteed to avoid collisions.
     if (!unique_names.count(field->name))
@@ skipping 287 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();
+}
+
+size_t FormStructure::RequiredFillableFields() const {
+  return IsAutocheckoutEnabled()? 0 : kRequiredFillableFields;
+}
+
 bool FormStructure::IsAutofillable(bool require_method_post) const {
-  // TODO(ramankk): Remove this check once we have better way of identifying the
-  // cases to trigger experimental form filling.
-  if (experimental_form_filling_enabled_)
-    return true;
-
-  if (autofill_count() < kRequiredFillableFields)
+  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 {
-  // TODO(ramankk): Remove this check once we have better way of identifying the
-  // cases to trigger experimental form filling.
-  if (experimental_form_filling_enabled_)
-    return true;
-
   // Ignore counting checkable elements towards minimum number of elements
   // required to parse. This avoids trying to crowdsource forms with few text
   // or select elements.
-  if ((field_count() - checkable_field_count()) < kRequiredFillableFields)
+  if ((field_count() - checkable_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;
 
   // Make sure there as at least one text field.
   bool has_text_field = false;
@@ skipping 177 matching lines @@
             AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_MATCH,
             experiment_id);
       } else {
         metric_logger.LogQualityMetric(
             AutofillMetrics::NOT_AUTOFILLED_SERVER_TYPE_MISMATCH,
             experiment_id);
       }
     }
   }
 
-  if (num_detected_field_types < kRequiredFillableFields) {
+  if (num_detected_field_types < RequiredFillableFields()) {
     metric_logger.LogUserHappinessMetric(
         AutofillMetrics::SUBMITTED_NON_FILLABLE_FORM);
   } else {
     if (did_autofill_all_possible_fields) {
       metric_logger.LogUserHappinessMetric(
           AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_ALL);
     } else if (did_autofill_some_possible_fields) {
       metric_logger.LogUserHappinessMetric(
           AutofillMetrics::SUBMITTED_FILLABLE_FORM_AUTOFILLED_SOME);
     } else {
@@ skipping 136 matching lines @@
         buzz::XmlElement *field_element = new buzz::XmlElement(
             buzz::QName(kXMLElementField));
 
         field_element->SetAttr(buzz::QName(kAttributeSignature),
                                field->FieldSignature());
         field_element->SetAttr(buzz::QName(kAttributeAutofillType),
                                base::IntToString(*field_type));
         encompassing_xml_element->AddElement(field_element);
       }
     } else {
-      // Skip putting checkable fields in the request if the flag is not set.
-      if (field->is_checkable && !experimental_form_filling_enabled_)
+      // Skip putting checkable fields in the request if autocheckout is not
+      // enabled.
+      if (field->is_checkable && !IsAutocheckoutEnabled())
         continue;
 
       buzz::XmlElement *field_element = new buzz::XmlElement(
           buzz::QName(kXMLElementField));
       field_element->SetAttr(buzz::QName(kAttributeSignature),
                              field->FieldSignature());
       encompassing_xml_element->AddElement(field_element);
     }
   }
   return true;
@@ skipping 162 matching lines @@
   for (std::vector<AutofillField*>::iterator field = fields_.begin();
        field != fields_.end(); ++field) {
     AutofillType::FieldTypeGroup field_type_group =
         AutofillType((*field)->type()).group();
     if (field_type_group == AutofillType::CREDIT_CARD)
       (*field)->set_section((*field)->section() + "-cc");
     else
       (*field)->set_section((*field)->section() + "-default");
   }
 }