Propagate correct data to the Toolbar servers

chrome/browser/autofill/autofill_manager.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/autofill_manager.h"
 
 #include <limits>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 201 matching lines @@
   if (!upload_form_structure_->ShouldBeParsed(true))
     return;
 
   FormStructure* cached_upload_form_structure = NULL;
   AutoFillField* ignored;
   if (!FindCachedFormAndField(form, form.fields.front(),
                               &cached_upload_form_structure, &ignored)) {
     cached_upload_form_structure = NULL;
   }
 
-  DeterminePossibleFieldTypesForUpload(cached_upload_form_structure);
+  std::string data_present = DeterminePossibleFieldTypesForUpload(
+      cached_upload_form_structure);
   // TODO(isherman): Consider uploading to server here rather than in
   // HandleSubmit().
 
   if (!upload_form_structure_->IsAutoFillable(true))
     return;
 
-  HandleSubmit();
+  HandleSubmit(data_present);
 }
 
 void AutoFillManager::OnFormsSeen(const std::vector<FormData>& forms) {
   if (!IsAutoFillEnabled())
     return;
 
   ParseForms(forms);
 }
 
 void AutoFillManager::OnQueryFormFieldAutoFill(
@@ skipping 237 matching lines @@
   if (prefs->FindPreference(prefs::kFormAutofillEnabled)) {
     bool enabled = prefs->GetBoolean(prefs::kFormAutofillEnabled);
     prefs->ClearPref(prefs::kFormAutofillEnabled);
     prefs->SetBoolean(prefs::kAutoFillEnabled, enabled);
     return enabled;
   }
 
   return prefs->GetBoolean(prefs::kAutoFillEnabled);
 }
 
-void AutoFillManager::DeterminePossibleFieldTypesForUpload(
+std::string AutoFillManager::DeterminePossibleFieldTypesForUpload(
     const FormStructure* cached_upload_form_structure) {
+  // Mark bits present for the upload for data_present field.
+  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) >> 3);
+  for (size_t i = 0; i < presence_bitfield.size(); ++i)
+    presence_bitfield[i] = 0;
+
   for (size_t i = 0; i < upload_form_structure_->field_count(); i++) {
     const AutoFillField* field = upload_form_structure_->field(i);
     FieldTypeSet field_types;
     personal_data_->GetPossibleFieldTypes(field->value(), &field_types);
+    if (field_types.size() > 1) {
+      // If there is more than one possibility, do not poison the crowd-sourced
+      // data by returning UNKNOWN_TYPE.
+      field_types.clear();
+      field_types.insert(UNKNOWN_TYPE);
+    }
     DCHECK(!field_types.empty());
+    SetPresenceBit(*(field_types.begin()), &presence_bitfield);
+
     upload_form_structure_->set_possible_types(i, field_types);
 
     if (field->form_control_type() == ASCIIToUTF16("select-one")) {
       // TODO(isherman): <select> fields don't support |is_autofilled()|. Since
       // this is heavily relied upon by our metrics, we just don't log anything
       // for all <select> fields. Better to have less data than misleading data.
       continue;
     }
 
     // Log various quality metrics.
@@ skipping 28 matching lines @@
 
 
       // TODO(isherman): Other things we might want to log here:
       // * Per Vadim's email, a combination of (1) whether heuristics fired,
       //   (2) whether the server returned something interesting, (3) whether
       //   the user filled the field
       // * Whether the server type matches the heursitic type
       //   - Perhaps only if at least one of the types is not unknown/no data.
     }
   }
+
+  return ConvertPresenceBitsToString(presence_bitfield);
 }
 
-void AutoFillManager::HandleSubmit() {
+void AutoFillManager::HandleSubmit(std::string const& data_present) {
   // If there wasn't enough data to import then we don't want to send an upload
   // to the server.
   // TODO(jhawkins): Import form data from |form_structures_|.  That will
   // require querying the FormManager for updated field values.
   std::vector<FormStructure*> import;
   import.push_back(upload_form_structure_.get());
   if (!personal_data_->ImportFormData(import))
     return;
 
   // Did we get credit card info?
   AutoFillProfile* profile;
   CreditCard* credit_card;
   personal_data_->GetImportedFormData(&profile, &credit_card);
 
   if (!credit_card) {
-    UploadFormData();
+    data_autofilled_.clear();
+    UploadFormData(data_present);
     return;
+  } else {
+    data_autofilled_ = data_present;
   }
 
   // Show an infobar to offer to save the credit card info.
   if (tab_contents_) {
     tab_contents_->AddInfoBar(new AutoFillCCInfoBarDelegate(tab_contents_,
                                                             this));
   }
 }
 
-void AutoFillManager::UploadFormData() {
+void AutoFillManager::UploadFormData(std::string const& data_present) {
   if (!disable_download_manager_requests_ && upload_form_structure_.get()) {
     bool was_autofilled = false;
     // Check if the form among last 3 forms that were auto-filled.
     // Clear older signatures.
     std::list<std::string>::iterator it;
     int total_form_checked = 0;
     for (it = autofilled_forms_signatures_.begin();
          it != autofilled_forms_signatures_.end() && total_form_checked < 3;
          ++it, ++total_form_checked) {
-      if (*it == upload_form_structure_->FormSignature())
+      if (*it == upload_form_structure_->FormSignature()) {
         was_autofilled = true;
+      }
     }
     // Remove outdated form signatures.
     if (total_form_checked == 3 && it != autofilled_forms_signatures_.end()) {
       autofilled_forms_signatures_.erase(it,
                                          autofilled_forms_signatures_.end());
     }
     download_manager_.StartUploadRequest(*(upload_form_structure_.get()),
-                                         was_autofilled);
+                                         was_autofilled,
+                                         data_present.c_str());
   }
 }
 
 void AutoFillManager::Reset() {
   upload_form_structure_.reset();
   form_structures_.reset();
 }
 
+void AutoFillManager::SetPresenceBit(AutoFillFieldType field_type,
+                                     std::vector<uint8>* bitfield) {
+  DCHECK(bitfield);
+  DCHECK(bitfield->size() > (static_cast<size_t>(field_type) >> 3));
+  // Set bit in the bitfield: byte |field_type| / 8, bit in byte
+  // |field_type| % 8 from the left.
+  (*bitfield)[field_type >> 3] |= (0x80 >> (field_type & 7));
+}
+
+std::string AutoFillManager::ConvertPresenceBitsToString(
+    std::vector<uint8> const& bitfield) {
+  std::string present_data;
+  present_data.reserve(bitfield.size() * 2 + 1);
+  // Skip leading zeroes. If all mask is 0 - return empty string.
+  size_t data_end = bitfield.size();
+  for (; data_end > 0 && !bitfield[data_end - 1]; --data_end) {
+  }
+  // Print all non-zero bytes into the string.
+  for (size_t i = 0; i < data_end; ++i) {
+    base::StringAppendF(&present_data, "%02x", bitfield[i]);
+  }
+  return present_data;
+}
+
 void AutoFillManager::OnInfoBarClosed(bool should_save) {
   if (should_save)
     personal_data_->SaveImportedCreditCard();
-  UploadFormData();
+  UploadFormData(data_autofilled_);
 }
 
 AutoFillManager::AutoFillManager()
     : tab_contents_(NULL),
       personal_data_(NULL),
       download_manager_(NULL),
       disable_download_manager_requests_(true),
       metric_logger_(new AutoFillMetrics),
       cc_infobar_(NULL) {
 }
@@ skipping 273 matching lines @@
     return std::string();
 
   std::map<int, std::string>::const_iterator iter = id_guid_map_.find(id);
   if (iter == id_guid_map_.end()) {
     NOTREACHED();
     return std::string();
   }
 
   return iter->second;
 }