Propagate correct data to the Toolbar servers

chrome/browser/autofill/form_structure.cc

 // Copyright (c) 2010 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 "base/basictypes.h"
 #include "base/logging.h"
 #include "base/sha1.h"
 #include "base/string_number_conversions.h"
@@ skipping 95 matching lines @@
 
 bool FormStructure::EncodeUploadRequest(bool auto_fill_used,
                                         std::string* encoded_xml) const {
   DCHECK(encoded_xml);
   encoded_xml->clear();
   bool auto_fillable = IsAutoFillable(false);
   DCHECK(auto_fillable);  // Caller should've checked for search pages.
   if (!auto_fillable)
     return false;
 
-  buzz::XmlElement autofil_request_xml(buzz::QName("autofillupload"));
+  buzz::XmlElement autofill_request_xml(buzz::QName("autofillupload"));
 
   // Attributes for the <autofillupload> element.
   //
   // TODO(jhawkins): Work with toolbar devs to make a spec for autofill clients.
   // For now these values are hacked from the toolbar code.
-  autofil_request_xml.SetAttr(buzz::QName(kAttributeClientVersion),
-                              "6.1.1715.1442/en (GGLL)");
+  autofill_request_xml.SetAttr(buzz::QName(kAttributeClientVersion),
+                               "6.1.1715.1442/en (GGLL)");
 
-  autofil_request_xml.SetAttr(buzz::QName(kAttributeFormSignature),
-                              FormSignature());
+  autofill_request_xml.SetAttr(buzz::QName(kAttributeFormSignature),
+                               FormSignature());
 
-  autofil_request_xml.SetAttr(buzz::QName(kAttributeAutoFillUsed),
-                              auto_fill_used ? "true" : "false");
+  autofill_request_xml.SetAttr(buzz::QName(kAttributeAutoFillUsed),
+                               auto_fill_used ? "true" : "false");
 
-  // TODO(jhawkins): Hook this up to the personal data manager.
-  // personaldata_manager_->GetDataPresent();
-  autofil_request_xml.SetAttr(buzz::QName(kAttributeDataPresent), "");
+  autofill_request_xml.SetAttr(buzz::QName(kAttributeDataPresent),
+                               ConvertPresenceBitsToString().c_str());
 
-  if (!EncodeFormRequest(FormStructure::UPLOAD, &autofil_request_xml))
+  if (!EncodeFormRequest(FormStructure::UPLOAD, &autofill_request_xml))
     return false;  // Malformed form, skip it.
 
   // Obtain the XML structure as a string.
   *encoded_xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
-  *encoded_xml += autofil_request_xml.Str().c_str();
+  *encoded_xml += autofill_request_xml.Str().c_str();
 
   return true;
 }
 
 // static
 bool FormStructure::EncodeQueryRequest(const ScopedVector<FormStructure>& forms,
     std::vector<std::string>* encoded_signatures,
     std::string* encoded_xml) {
   DCHECK(encoded_signatures);
   DCHECK(encoded_xml);
   encoded_xml->clear();
   encoded_signatures->clear();
   encoded_signatures->reserve(forms.size());
-  buzz::XmlElement autofil_request_xml(buzz::QName("autofillquery"));
+  buzz::XmlElement autofill_request_xml(buzz::QName("autofillquery"));
   // Attributes for the <autofillquery> element.
   //
   // TODO(jhawkins): Work with toolbar devs to make a spec for autofill clients.
   // For now these values are hacked from the toolbar code.
-  autofil_request_xml.SetAttr(buzz::QName(kAttributeClientVersion),
-                              "6.1.1715.1442/en (GGLL)");
+  autofill_request_xml.SetAttr(buzz::QName(kAttributeClientVersion),
+                               "6.1.1715.1442/en (GGLL)");
   // 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("form")));
     encompassing_xml_element->SetAttr(buzz::QName(kAttributeSignature),
                                       signature);
 
     if (!(*it)->EncodeFormRequest(FormStructure::QUERY,
                                   encompassing_xml_element.get()))
       continue;  // Malformed form, skip it.
 
-    autofil_request_xml.AddElement(encompassing_xml_element.release());
+    autofill_request_xml.AddElement(encompassing_xml_element.release());
     encoded_signatures->push_back(signature);
   }
 
   if (!encoded_signatures->size())
     return false;
 
   // Obtain the XML structure as a string.
   *encoded_xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
-  *encoded_xml += autofil_request_xml.Str().c_str();
+  *encoded_xml += autofill_request_xml.Str().c_str();
 
   return true;
 }
 
 // static
 void FormStructure::ParseQueryResponse(const std::string& response_xml,
                                        const std::vector<FormStructure*>& forms,
                                        UploadRequired* upload_required,
                                        const AutoFillMetrics& metric_logger) {
   metric_logger.Log(AutoFillMetrics::QUERY_RESPONSE_RECEIVED);
@@ skipping 206 matching lines @@
   if (field_count() > kMaxFieldsOnTheForm) {
     // This is not a valid form, most certainly. Do not send request for the
     // wrongly formatted forms.
     return false;
   }
   // Add the child nodes for the form fields.
   for (size_t index = 0; index < field_count(); ++index) {
     const AutoFillField* field = fields_[index];
     if (request_type == FormStructure::UPLOAD) {
       FieldTypeSet types = field->possible_types();
-      for (FieldTypeSet::const_iterator type = types.begin();
-           type != types.end(); type++) {
+      // If we have more than one type for the field, report UNKNOWN_TYPE to not
+      // pollute crowd sourcing with inexact data.
+      if (!AllowedForUpload(types)) {
+        types.clear();
+        types.insert(UNKNOWN_TYPE);
+      }
+      for (FieldTypeSet::iterator field_type = types.begin();
+           field_type != types.end(); ++field_type) {
         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(*type));
+                               base::IntToString(*field_type));
         encompassing_xml_element->AddElement(field_element);
       }
     } else {
       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;
 }
+
+std::string FormStructure::ConvertPresenceBitsToString() const {
+  std::vector<uint8> presence_bitfield;
+  // Determine all of the field types that were autofilled. Pack bits into
+  // |presence_bitfield|. The necessary size for |presence_bitfield| is
+  // ceil((MAX_VALID_FIELD_TYPE + 7) / 8) bytes (uint8).
+  presence_bitfield.resize((MAX_VALID_FIELD_TYPE + 0x7) / 8);
+  for (size_t i = 0; i < presence_bitfield.size(); ++i)
+    presence_bitfield[i] = 0;
+
+  for (size_t i = 0; i < field_count(); ++i) {
+    const AutoFillField* field = fields_[i];
+    FieldTypeSet types = field->possible_types();
+    // If we have more than one type for the field, report UNKNOWN_TYPE to not
+    // pollute crowd sourcing with inexact data.
+    if (!AllowedForUpload(types)) {
+      types.clear();
+      types.insert(UNKNOWN_TYPE);
+    }

[Ilya Sherman, 2011/01/22 01:12:35]

nit: You already have this above; no need to do it again.

[GeorgeY, 2011/01/22 01:40:40]

Done.

+    for (FieldTypeSet::iterator field_type = types.begin();
+         field_type != types.end(); ++field_type) {
+      DCHECK(presence_bitfield.size() > (static_cast<size_t>(*field_type) / 8));
+      // Set bit in the bitfield: byte |field_type| / 8, bit in byte
+      // |field_type| % 8 from the left.
+      presence_bitfield[*field_type / 8] |= (0x80 >> (*field_type % 8));
+    }
+  }
+
+  std::string data_presence;
+  data_presence.reserve(presence_bitfield.size() * 2 + 1);
+
+  // Skip trailing zeroes. If all mask is 0 - return empty string.
+  size_t data_end = presence_bitfield.size();
+  for (; data_end > 0 && !presence_bitfield[data_end - 1]; --data_end) {
+  }
+
+  // Print all meaningfull bytes into the string.
+  for (size_t i = 0; i < data_end; ++i) {
+    base::StringAppendF(&data_presence, "%02x", presence_bitfield[i]);
+  }
+
+  return data_presence;
+}
+
+bool FormStructure::AllowedForUpload(FieldTypeSet const& field_set) {
+  // For each pair |field_set| allowed to be both types on the same line (nth
+  // and n+1th), so being ADDRESS_HOME_LINE1 and ADDRESS_BILLING_LINE1 is
+  // allowed, but ADDRESS_HOME_LINE1, ADDRESS_BILLING_LINE2 is not.
+  static AutoFillFieldType allowed_multi_fields[] = {
+    PHONE_FAX_CITY_CODE, PHONE_HOME_CITY_CODE,
+    PHONE_FAX_COUNTRY_CODE, PHONE_HOME_COUNTRY_CODE,
+    ADDRESS_HOME_LINE1, ADDRESS_BILLING_LINE1,
+    ADDRESS_HOME_LINE2, ADDRESS_BILLING_LINE2,
+    ADDRESS_HOME_APT_NUM, ADDRESS_BILLING_APT_NUM,
+    ADDRESS_HOME_CITY, ADDRESS_BILLING_CITY,
+    ADDRESS_HOME_STATE, ADDRESS_BILLING_STATE,
+    ADDRESS_HOME_ZIP, ADDRESS_BILLING_ZIP,
+    ADDRESS_HOME_COUNTRY, ADDRESS_BILLING_COUNTRY,
+  };
+  if (field_set.size() == 0 || field_set.size() > 2) {
+    return false;
+  } else if (field_set.size() == 1) {
+    return true;
+  } else {
+    DCHECK((arraysize(allowed_multi_fields) & 1) == 0);

[Ilya Sherman, 2011/01/22 01:12:35]

nit: Please write this as "% 2" rather than "& 1"

[GeorgeY, 2011/01/22 01:40:40]

Done.

+    for (size_t i = 0; i < arraysize(allowed_multi_fields); i += 2)
+      if (field_set.find(allowed_multi_fields[i]) != field_set.end() &&
+          field_set.find(allowed_multi_fields[i + 1]) != field_set.end())
+        return true;
+  }
+  return false;
+}

[Ilya Sherman, 2011/01/22 01:12:35]

nit: This was the extra code complexity that I was referring to ;)

[GeorgeY, 2011/01/22 01:40:40]

removed

+